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     if (T->isConstrained()) {
1050       OS << T->getTypeConstraintConcept()->getName();
1051       auto Args = T->getTypeConstraintArguments();
1052       if (!Args.empty())
1053         printTemplateArgumentList(OS, Args, Policy);
1054       OS << ' ';
1055     }
1056     switch (T->getKeyword()) {
1057     case AutoTypeKeyword::Auto: OS << "auto"; break;
1058     case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break;
1059     case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break;
1060     }
1061     spaceBeforePlaceHolder(OS);
1062   }
1063 }
1064 
1065 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
1066   // If the type has been deduced, do not print 'auto'.
1067   if (!T->getDeducedType().isNull())
1068     printAfter(T->getDeducedType(), OS);
1069 }
1070 
1071 void TypePrinter::printDeducedTemplateSpecializationBefore(
1072     const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
1073   // If the type has been deduced, print the deduced type.
1074   if (!T->getDeducedType().isNull()) {
1075     printBefore(T->getDeducedType(), OS);
1076   } else {
1077     IncludeStrongLifetimeRAII Strong(Policy);
1078     T->getTemplateName().print(OS, Policy);
1079     spaceBeforePlaceHolder(OS);
1080   }
1081 }
1082 
1083 void TypePrinter::printDeducedTemplateSpecializationAfter(
1084     const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
1085   // If the type has been deduced, print the deduced type.
1086   if (!T->getDeducedType().isNull())
1087     printAfter(T->getDeducedType(), OS);
1088 }
1089 
1090 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) {
1091   IncludeStrongLifetimeRAII Strong(Policy);
1092 
1093   OS << "_Atomic(";
1094   print(T->getValueType(), OS, StringRef());
1095   OS << ')';
1096   spaceBeforePlaceHolder(OS);
1097 }
1098 
1099 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {}
1100 
1101 void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) {
1102   IncludeStrongLifetimeRAII Strong(Policy);
1103 
1104   if (T->isReadOnly())
1105     OS << "read_only ";
1106   else
1107     OS << "write_only ";
1108   OS << "pipe ";
1109   print(T->getElementType(), OS, StringRef());
1110   spaceBeforePlaceHolder(OS);
1111 }
1112 
1113 void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {}
1114 
1115 /// Appends the given scope to the end of a string.
1116 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) {
1117   if (DC->isTranslationUnit()) return;
1118   if (DC->isFunctionOrMethod()) return;
1119   AppendScope(DC->getParent(), OS);
1120 
1121   if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
1122     if (Policy.SuppressUnwrittenScope &&
1123         (NS->isAnonymousNamespace() || NS->isInline()))
1124       return;
1125     if (NS->getIdentifier())
1126       OS << NS->getName() << "::";
1127     else
1128       OS << "(anonymous namespace)::";
1129   } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1130     IncludeStrongLifetimeRAII Strong(Policy);
1131     OS << Spec->getIdentifier()->getName();
1132     const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1133     printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
1134     OS << "::";
1135   } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) {
1136     if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
1137       OS << Typedef->getIdentifier()->getName() << "::";
1138     else if (Tag->getIdentifier())
1139       OS << Tag->getIdentifier()->getName() << "::";
1140     else
1141       return;
1142   }
1143 }
1144 
1145 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
1146   if (Policy.IncludeTagDefinition) {
1147     PrintingPolicy SubPolicy = Policy;
1148     SubPolicy.IncludeTagDefinition = false;
1149     D->print(OS, SubPolicy, Indentation);
1150     spaceBeforePlaceHolder(OS);
1151     return;
1152   }
1153 
1154   bool HasKindDecoration = false;
1155 
1156   // We don't print tags unless this is an elaborated type.
1157   // In C, we just assume every RecordType is an elaborated type.
1158   if (!Policy.SuppressTagKeyword && !D->getTypedefNameForAnonDecl()) {
1159     HasKindDecoration = true;
1160     OS << D->getKindName();
1161     OS << ' ';
1162   }
1163 
1164   // Compute the full nested-name-specifier for this type.
1165   // In C, this will always be empty except when the type
1166   // being printed is anonymous within other Record.
1167   if (!Policy.SuppressScope)
1168     AppendScope(D->getDeclContext(), OS);
1169 
1170   if (const IdentifierInfo *II = D->getIdentifier())
1171     OS << II->getName();
1172   else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
1173     assert(Typedef->getIdentifier() && "Typedef without identifier?");
1174     OS << Typedef->getIdentifier()->getName();
1175   } else {
1176     // Make an unambiguous representation for anonymous types, e.g.
1177     //   (anonymous enum at /usr/include/string.h:120:9)
1178     OS << (Policy.MSVCFormatting ? '`' : '(');
1179 
1180     if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) {
1181       OS << "lambda";
1182       HasKindDecoration = true;
1183     } else {
1184       OS << "anonymous";
1185     }
1186 
1187     if (Policy.AnonymousTagLocations) {
1188       // Suppress the redundant tag keyword if we just printed one.
1189       // We don't have to worry about ElaboratedTypes here because you can't
1190       // refer to an anonymous type with one.
1191       if (!HasKindDecoration)
1192         OS << " " << D->getKindName();
1193 
1194       PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc(
1195           D->getLocation());
1196       if (PLoc.isValid()) {
1197         OS << " at ";
1198         StringRef File = PLoc.getFilename();
1199         if (auto *Callbacks = Policy.Callbacks)
1200           OS << Callbacks->remapPath(File);
1201         else
1202           OS << File;
1203         OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
1204       }
1205     }
1206 
1207     OS << (Policy.MSVCFormatting ? '\'' : ')');
1208   }
1209 
1210   // If this is a class template specialization, print the template
1211   // arguments.
1212   if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
1213     ArrayRef<TemplateArgument> Args;
1214     TypeSourceInfo *TAW = Spec->getTypeAsWritten();
1215     if (!Policy.PrintCanonicalTypes && TAW) {
1216       const TemplateSpecializationType *TST =
1217         cast<TemplateSpecializationType>(TAW->getType());
1218       Args = TST->template_arguments();
1219     } else {
1220       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1221       Args = TemplateArgs.asArray();
1222     }
1223     IncludeStrongLifetimeRAII Strong(Policy);
1224     printTemplateArgumentList(OS, Args, Policy);
1225   }
1226 
1227   spaceBeforePlaceHolder(OS);
1228 }
1229 
1230 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
1231   printTag(T->getDecl(), OS);
1232 }
1233 
1234 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {}
1235 
1236 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
1237   printTag(T->getDecl(), OS);
1238 }
1239 
1240 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {}
1241 
1242 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
1243                                               raw_ostream &OS) {
1244   TemplateTypeParmDecl *D = T->getDecl();
1245   if (D && D->isImplicit()) {
1246     if (auto *TC = D->getTypeConstraint()) {
1247       TC->print(OS, Policy);
1248       OS << ' ';
1249     }
1250     OS << "auto";
1251   } else if (IdentifierInfo *Id = T->getIdentifier())
1252     OS << Id->getName();
1253   else
1254     OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
1255 
1256   spaceBeforePlaceHolder(OS);
1257 }
1258 
1259 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
1260                                              raw_ostream &OS) {}
1261 
1262 void TypePrinter::printSubstTemplateTypeParmBefore(
1263                                              const SubstTemplateTypeParmType *T,
1264                                              raw_ostream &OS) {
1265   IncludeStrongLifetimeRAII Strong(Policy);
1266   printBefore(T->getReplacementType(), OS);
1267 }
1268 
1269 void TypePrinter::printSubstTemplateTypeParmAfter(
1270                                              const SubstTemplateTypeParmType *T,
1271                                              raw_ostream &OS) {
1272   IncludeStrongLifetimeRAII Strong(Policy);
1273   printAfter(T->getReplacementType(), OS);
1274 }
1275 
1276 void TypePrinter::printSubstTemplateTypeParmPackBefore(
1277                                         const SubstTemplateTypeParmPackType *T,
1278                                         raw_ostream &OS) {
1279   IncludeStrongLifetimeRAII Strong(Policy);
1280   printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1281 }
1282 
1283 void TypePrinter::printSubstTemplateTypeParmPackAfter(
1284                                         const SubstTemplateTypeParmPackType *T,
1285                                         raw_ostream &OS) {
1286   IncludeStrongLifetimeRAII Strong(Policy);
1287   printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1288 }
1289 
1290 void TypePrinter::printTemplateSpecializationBefore(
1291                                             const TemplateSpecializationType *T,
1292                                             raw_ostream &OS) {
1293   IncludeStrongLifetimeRAII Strong(Policy);
1294   T->getTemplateName().print(OS, Policy);
1295 
1296   printTemplateArgumentList(OS, T->template_arguments(), Policy);
1297   spaceBeforePlaceHolder(OS);
1298 }
1299 
1300 void TypePrinter::printTemplateSpecializationAfter(
1301                                             const TemplateSpecializationType *T,
1302                                             raw_ostream &OS) {}
1303 
1304 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
1305                                                raw_ostream &OS) {
1306   printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1307 }
1308 
1309 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
1310                                                raw_ostream &OS) {}
1311 
1312 void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
1313                                         raw_ostream &OS) {
1314   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) {
1315     TagDecl *OwnedTagDecl = T->getOwnedTagDecl();
1316     assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() &&
1317            "OwnedTagDecl expected to be a declaration for the type");
1318     PrintingPolicy SubPolicy = Policy;
1319     SubPolicy.IncludeTagDefinition = false;
1320     OwnedTagDecl->print(OS, SubPolicy, Indentation);
1321     spaceBeforePlaceHolder(OS);
1322     return;
1323   }
1324 
1325   // The tag definition will take care of these.
1326   if (!Policy.IncludeTagDefinition)
1327   {
1328     OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1329     if (T->getKeyword() != ETK_None)
1330       OS << " ";
1331     NestedNameSpecifier *Qualifier = T->getQualifier();
1332     if (Qualifier)
1333       Qualifier->print(OS, Policy);
1334   }
1335 
1336   ElaboratedTypePolicyRAII PolicyRAII(Policy);
1337   printBefore(T->getNamedType(), OS);
1338 }
1339 
1340 void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
1341                                         raw_ostream &OS) {
1342   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl())
1343     return;
1344   ElaboratedTypePolicyRAII PolicyRAII(Policy);
1345   printAfter(T->getNamedType(), OS);
1346 }
1347 
1348 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
1349   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1350     printBefore(T->getInnerType(), OS);
1351     OS << '(';
1352   } else
1353     printBefore(T->getInnerType(), OS);
1354 }
1355 
1356 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
1357   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1358     OS << ')';
1359     printAfter(T->getInnerType(), OS);
1360   } else
1361     printAfter(T->getInnerType(), OS);
1362 }
1363 
1364 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
1365                                            raw_ostream &OS) {
1366   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1367   if (T->getKeyword() != ETK_None)
1368     OS << " ";
1369 
1370   T->getQualifier()->print(OS, Policy);
1371 
1372   OS << T->getIdentifier()->getName();
1373   spaceBeforePlaceHolder(OS);
1374 }
1375 
1376 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
1377                                           raw_ostream &OS) {}
1378 
1379 void TypePrinter::printDependentTemplateSpecializationBefore(
1380         const DependentTemplateSpecializationType *T, raw_ostream &OS) {
1381   IncludeStrongLifetimeRAII Strong(Policy);
1382 
1383   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1384   if (T->getKeyword() != ETK_None)
1385     OS << " ";
1386 
1387   if (T->getQualifier())
1388     T->getQualifier()->print(OS, Policy);
1389   OS << T->getIdentifier()->getName();
1390   printTemplateArgumentList(OS, T->template_arguments(), Policy);
1391   spaceBeforePlaceHolder(OS);
1392 }
1393 
1394 void TypePrinter::printDependentTemplateSpecializationAfter(
1395         const DependentTemplateSpecializationType *T, raw_ostream &OS) {}
1396 
1397 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
1398                                            raw_ostream &OS) {
1399   printBefore(T->getPattern(), OS);
1400 }
1401 
1402 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
1403                                           raw_ostream &OS) {
1404   printAfter(T->getPattern(), OS);
1405   OS << "...";
1406 }
1407 
1408 void TypePrinter::printAttributedBefore(const AttributedType *T,
1409                                         raw_ostream &OS) {
1410   // FIXME: Generate this with TableGen.
1411 
1412   // Prefer the macro forms of the GC and ownership qualifiers.
1413   if (T->getAttrKind() == attr::ObjCGC ||
1414       T->getAttrKind() == attr::ObjCOwnership)
1415     return printBefore(T->getEquivalentType(), OS);
1416 
1417   if (T->getAttrKind() == attr::ObjCKindOf)
1418     OS << "__kindof ";
1419 
1420   if (T->getAttrKind() == attr::AddressSpace)
1421     printBefore(T->getEquivalentType(), OS);
1422   else
1423     printBefore(T->getModifiedType(), OS);
1424 
1425   if (T->isMSTypeSpec()) {
1426     switch (T->getAttrKind()) {
1427     default: return;
1428     case attr::Ptr32: OS << " __ptr32"; break;
1429     case attr::Ptr64: OS << " __ptr64"; break;
1430     case attr::SPtr: OS << " __sptr"; break;
1431     case attr::UPtr: OS << " __uptr"; break;
1432     }
1433     spaceBeforePlaceHolder(OS);
1434   }
1435 
1436   // Print nullability type specifiers.
1437   if (T->getImmediateNullability()) {
1438     if (T->getAttrKind() == attr::TypeNonNull)
1439       OS << " _Nonnull";
1440     else if (T->getAttrKind() == attr::TypeNullable)
1441       OS << " _Nullable";
1442     else if (T->getAttrKind() == attr::TypeNullUnspecified)
1443       OS << " _Null_unspecified";
1444     else
1445       llvm_unreachable("unhandled nullability");
1446     spaceBeforePlaceHolder(OS);
1447   }
1448 }
1449 
1450 void TypePrinter::printAttributedAfter(const AttributedType *T,
1451                                        raw_ostream &OS) {
1452   // FIXME: Generate this with TableGen.
1453 
1454   // Prefer the macro forms of the GC and ownership qualifiers.
1455   if (T->getAttrKind() == attr::ObjCGC ||
1456       T->getAttrKind() == attr::ObjCOwnership)
1457     return printAfter(T->getEquivalentType(), OS);
1458 
1459   // If this is a calling convention attribute, don't print the implicit CC from
1460   // the modified type.
1461   SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv());
1462 
1463   printAfter(T->getModifiedType(), OS);
1464 
1465   // Some attributes are printed as qualifiers before the type, so we have
1466   // nothing left to do.
1467   if (T->getAttrKind() == attr::ObjCKindOf ||
1468       T->isMSTypeSpec() || T->getImmediateNullability())
1469     return;
1470 
1471   // Don't print the inert __unsafe_unretained attribute at all.
1472   if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained)
1473     return;
1474 
1475   // Don't print ns_returns_retained unless it had an effect.
1476   if (T->getAttrKind() == attr::NSReturnsRetained &&
1477       !T->getEquivalentType()->castAs<FunctionType>()
1478                              ->getExtInfo().getProducesResult())
1479     return;
1480 
1481   if (T->getAttrKind() == attr::LifetimeBound) {
1482     OS << " [[clang::lifetimebound]]";
1483     return;
1484   }
1485 
1486   // The printing of the address_space attribute is handled by the qualifier
1487   // since it is still stored in the qualifier. Return early to prevent printing
1488   // this twice.
1489   if (T->getAttrKind() == attr::AddressSpace)
1490     return;
1491 
1492   OS << " __attribute__((";
1493   switch (T->getAttrKind()) {
1494 #define TYPE_ATTR(NAME)
1495 #define DECL_OR_TYPE_ATTR(NAME)
1496 #define ATTR(NAME) case attr::NAME:
1497 #include "clang/Basic/AttrList.inc"
1498     llvm_unreachable("non-type attribute attached to type");
1499 
1500   case attr::OpenCLPrivateAddressSpace:
1501   case attr::OpenCLGlobalAddressSpace:
1502   case attr::OpenCLLocalAddressSpace:
1503   case attr::OpenCLConstantAddressSpace:
1504   case attr::OpenCLGenericAddressSpace:
1505     // FIXME: Update printAttributedBefore to print these once we generate
1506     // AttributedType nodes for them.
1507     break;
1508 
1509   case attr::LifetimeBound:
1510   case attr::TypeNonNull:
1511   case attr::TypeNullable:
1512   case attr::TypeNullUnspecified:
1513   case attr::ObjCGC:
1514   case attr::ObjCInertUnsafeUnretained:
1515   case attr::ObjCKindOf:
1516   case attr::ObjCOwnership:
1517   case attr::Ptr32:
1518   case attr::Ptr64:
1519   case attr::SPtr:
1520   case attr::UPtr:
1521   case attr::AddressSpace:
1522     llvm_unreachable("This attribute should have been handled already");
1523 
1524   case attr::NSReturnsRetained:
1525     OS << "ns_returns_retained";
1526     break;
1527 
1528   // FIXME: When Sema learns to form this AttributedType, avoid printing the
1529   // attribute again in printFunctionProtoAfter.
1530   case attr::AnyX86NoCfCheck: OS << "nocf_check"; break;
1531   case attr::CDecl: OS << "cdecl"; break;
1532   case attr::FastCall: OS << "fastcall"; break;
1533   case attr::StdCall: OS << "stdcall"; break;
1534   case attr::ThisCall: OS << "thiscall"; break;
1535   case attr::SwiftCall: OS << "swiftcall"; break;
1536   case attr::VectorCall: OS << "vectorcall"; break;
1537   case attr::Pascal: OS << "pascal"; break;
1538   case attr::MSABI: OS << "ms_abi"; break;
1539   case attr::SysVABI: OS << "sysv_abi"; break;
1540   case attr::RegCall: OS << "regcall"; break;
1541   case attr::Pcs: {
1542     OS << "pcs(";
1543    QualType t = T->getEquivalentType();
1544    while (!t->isFunctionType())
1545      t = t->getPointeeType();
1546    OS << (t->castAs<FunctionType>()->getCallConv() == CC_AAPCS ?
1547          "\"aapcs\"" : "\"aapcs-vfp\"");
1548    OS << ')';
1549    break;
1550   }
1551   case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break;
1552   case attr::IntelOclBicc: OS << "inteloclbicc"; break;
1553   case attr::PreserveMost:
1554     OS << "preserve_most";
1555     break;
1556 
1557   case attr::PreserveAll:
1558     OS << "preserve_all";
1559     break;
1560   case attr::NoDeref:
1561     OS << "noderef";
1562     break;
1563   case attr::AcquireHandle:
1564     OS << "acquire_handle";
1565     break;
1566   }
1567   OS << "))";
1568 }
1569 
1570 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
1571                                            raw_ostream &OS) {
1572   OS << T->getDecl()->getName();
1573   spaceBeforePlaceHolder(OS);
1574 }
1575 
1576 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
1577                                           raw_ostream &OS) {}
1578 
1579 void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T,
1580                                           raw_ostream &OS) {
1581   OS << T->getDecl()->getName();
1582   if (!T->qual_empty()) {
1583     bool isFirst = true;
1584     OS << '<';
1585     for (const auto *I : T->quals()) {
1586       if (isFirst)
1587         isFirst = false;
1588       else
1589         OS << ',';
1590       OS << I->getName();
1591     }
1592     OS << '>';
1593   }
1594 
1595   spaceBeforePlaceHolder(OS);
1596 }
1597 
1598 void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T,
1599                                           raw_ostream &OS) {}
1600 
1601 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
1602                                         raw_ostream &OS) {
1603   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1604       !T->isKindOfTypeAsWritten())
1605     return printBefore(T->getBaseType(), OS);
1606 
1607   if (T->isKindOfTypeAsWritten())
1608     OS << "__kindof ";
1609 
1610   print(T->getBaseType(), OS, StringRef());
1611 
1612   if (T->isSpecializedAsWritten()) {
1613     bool isFirst = true;
1614     OS << '<';
1615     for (auto typeArg : T->getTypeArgsAsWritten()) {
1616       if (isFirst)
1617         isFirst = false;
1618       else
1619         OS << ",";
1620 
1621       print(typeArg, OS, StringRef());
1622     }
1623     OS << '>';
1624   }
1625 
1626   if (!T->qual_empty()) {
1627     bool isFirst = true;
1628     OS << '<';
1629     for (const auto *I : T->quals()) {
1630       if (isFirst)
1631         isFirst = false;
1632       else
1633         OS << ',';
1634       OS << I->getName();
1635     }
1636     OS << '>';
1637   }
1638 
1639   spaceBeforePlaceHolder(OS);
1640 }
1641 
1642 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
1643                                         raw_ostream &OS) {
1644   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1645       !T->isKindOfTypeAsWritten())
1646     return printAfter(T->getBaseType(), OS);
1647 }
1648 
1649 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
1650                                                raw_ostream &OS) {
1651   printBefore(T->getPointeeType(), OS);
1652 
1653   // If we need to print the pointer, print it now.
1654   if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() &&
1655       !T->isObjCClassType() && !T->isObjCQualifiedClassType()) {
1656     if (HasEmptyPlaceHolder)
1657       OS << ' ';
1658     OS << '*';
1659   }
1660 }
1661 
1662 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
1663                                               raw_ostream &OS) {}
1664 
1665 static
1666 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
1667 
1668 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
1669   return A.getArgument();
1670 }
1671 
1672 static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP,
1673                           llvm::raw_ostream &OS) {
1674   A.print(PP, OS);
1675 }
1676 
1677 static void printArgument(const TemplateArgumentLoc &A,
1678                           const PrintingPolicy &PP, llvm::raw_ostream &OS) {
1679   const TemplateArgument::ArgKind &Kind = A.getArgument().getKind();
1680   if (Kind == TemplateArgument::ArgKind::Type)
1681     return A.getTypeSourceInfo()->getType().print(OS, PP);
1682   return A.getArgument().print(PP, OS);
1683 }
1684 
1685 template<typename TA>
1686 static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
1687                     const PrintingPolicy &Policy, bool SkipBrackets) {
1688   const char *Comma = Policy.MSVCFormatting ? "," : ", ";
1689   if (!SkipBrackets)
1690     OS << '<';
1691 
1692   bool NeedSpace = false;
1693   bool FirstArg = true;
1694   for (const auto &Arg : Args) {
1695     // Print the argument into a string.
1696     SmallString<128> Buf;
1697     llvm::raw_svector_ostream ArgOS(Buf);
1698     const TemplateArgument &Argument = getArgument(Arg);
1699     if (Argument.getKind() == TemplateArgument::Pack) {
1700       if (Argument.pack_size() && !FirstArg)
1701         OS << Comma;
1702       printTo(ArgOS, Argument.getPackAsArray(), Policy, true);
1703     } else {
1704       if (!FirstArg)
1705         OS << Comma;
1706       // Tries to print the argument with location info if exists.
1707       printArgument(Arg, Policy, ArgOS);
1708     }
1709     StringRef ArgString = ArgOS.str();
1710 
1711     // If this is the first argument and its string representation
1712     // begins with the global scope specifier ('::foo'), add a space
1713     // to avoid printing the diagraph '<:'.
1714     if (FirstArg && !ArgString.empty() && ArgString[0] == ':')
1715       OS << ' ';
1716 
1717     OS << ArgString;
1718 
1719     NeedSpace = (!ArgString.empty() && ArgString.back() == '>');
1720     FirstArg = false;
1721   }
1722 
1723   // If the last character of our string is '>', add another space to
1724   // keep the two '>''s separate tokens. We don't *have* to do this in
1725   // C++0x, but it's still good hygiene.
1726   if (NeedSpace)
1727     OS << ' ';
1728 
1729   if (!SkipBrackets)
1730     OS << '>';
1731 }
1732 
1733 void clang::printTemplateArgumentList(raw_ostream &OS,
1734                                       const TemplateArgumentListInfo &Args,
1735                                       const PrintingPolicy &Policy) {
1736   return printTo(OS, Args.arguments(), Policy, false);
1737 }
1738 
1739 void clang::printTemplateArgumentList(raw_ostream &OS,
1740                                       ArrayRef<TemplateArgument> Args,
1741                                       const PrintingPolicy &Policy) {
1742   printTo(OS, Args, Policy, false);
1743 }
1744 
1745 void clang::printTemplateArgumentList(raw_ostream &OS,
1746                                       ArrayRef<TemplateArgumentLoc> Args,
1747                                       const PrintingPolicy &Policy) {
1748   printTo(OS, Args, Policy, false);
1749 }
1750 
1751 std::string Qualifiers::getAsString() const {
1752   LangOptions LO;
1753   return getAsString(PrintingPolicy(LO));
1754 }
1755 
1756 // Appends qualifiers to the given string, separated by spaces.  Will
1757 // prefix a space if the string is non-empty.  Will not append a final
1758 // space.
1759 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
1760   SmallString<64> Buf;
1761   llvm::raw_svector_ostream StrOS(Buf);
1762   print(StrOS, Policy);
1763   return StrOS.str();
1764 }
1765 
1766 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
1767   if (getCVRQualifiers())
1768     return false;
1769 
1770   if (getAddressSpace() != LangAS::Default)
1771     return false;
1772 
1773   if (getObjCGCAttr())
1774     return false;
1775 
1776   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
1777     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
1778       return false;
1779 
1780   return true;
1781 }
1782 
1783 std::string Qualifiers::getAddrSpaceAsString(LangAS AS) {
1784   switch (AS) {
1785   case LangAS::Default:
1786     return "";
1787   case LangAS::opencl_global:
1788     return "__global";
1789   case LangAS::opencl_local:
1790     return "__local";
1791   case LangAS::opencl_private:
1792     return "__private";
1793   case LangAS::opencl_constant:
1794     return "__constant";
1795   case LangAS::opencl_generic:
1796     return "__generic";
1797   case LangAS::cuda_device:
1798     return "__device__";
1799   case LangAS::cuda_constant:
1800     return "__constant__";
1801   case LangAS::cuda_shared:
1802     return "__shared__";
1803   case LangAS::ptr32_sptr:
1804     return "__sptr __ptr32";
1805   case LangAS::ptr32_uptr:
1806     return "__uptr __ptr32";
1807   case LangAS::ptr64:
1808     return "__ptr64";
1809   default:
1810     return std::to_string(toTargetAddressSpace(AS));
1811   }
1812 }
1813 
1814 // Appends qualifiers to the given string, separated by spaces.  Will
1815 // prefix a space if the string is non-empty.  Will not append a final
1816 // space.
1817 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
1818                        bool appendSpaceIfNonEmpty) const {
1819   bool addSpace = false;
1820 
1821   unsigned quals = getCVRQualifiers();
1822   if (quals) {
1823     AppendTypeQualList(OS, quals, Policy.Restrict);
1824     addSpace = true;
1825   }
1826   if (hasUnaligned()) {
1827     if (addSpace)
1828       OS << ' ';
1829     OS << "__unaligned";
1830     addSpace = true;
1831   }
1832   auto ASStr = getAddrSpaceAsString(getAddressSpace());
1833   if (!ASStr.empty()) {
1834     if (addSpace)
1835       OS << ' ';
1836     addSpace = true;
1837     // Wrap target address space into an attribute syntax
1838     if (isTargetAddressSpace(getAddressSpace()))
1839       OS << "__attribute__((address_space(" << ASStr << ")))";
1840     else
1841       OS << ASStr;
1842   }
1843 
1844   if (Qualifiers::GC gc = getObjCGCAttr()) {
1845     if (addSpace)
1846       OS << ' ';
1847     addSpace = true;
1848     if (gc == Qualifiers::Weak)
1849       OS << "__weak";
1850     else
1851       OS << "__strong";
1852   }
1853   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
1854     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
1855       if (addSpace)
1856         OS << ' ';
1857       addSpace = true;
1858     }
1859 
1860     switch (lifetime) {
1861     case Qualifiers::OCL_None: llvm_unreachable("none but true");
1862     case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
1863     case Qualifiers::OCL_Strong:
1864       if (!Policy.SuppressStrongLifetime)
1865         OS << "__strong";
1866       break;
1867 
1868     case Qualifiers::OCL_Weak: OS << "__weak"; break;
1869     case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
1870     }
1871   }
1872 
1873   if (appendSpaceIfNonEmpty && addSpace)
1874     OS << ' ';
1875 }
1876 
1877 std::string QualType::getAsString() const {
1878   return getAsString(split(), LangOptions());
1879 }
1880 
1881 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
1882   std::string S;
1883   getAsStringInternal(S, Policy);
1884   return S;
1885 }
1886 
1887 std::string QualType::getAsString(const Type *ty, Qualifiers qs,
1888                                   const PrintingPolicy &Policy) {
1889   std::string buffer;
1890   getAsStringInternal(ty, qs, buffer, Policy);
1891   return buffer;
1892 }
1893 
1894 void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy,
1895                      const Twine &PlaceHolder, unsigned Indentation) const {
1896   print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder,
1897         Indentation);
1898 }
1899 
1900 void QualType::print(const Type *ty, Qualifiers qs,
1901                      raw_ostream &OS, const PrintingPolicy &policy,
1902                      const Twine &PlaceHolder, unsigned Indentation) {
1903   SmallString<128> PHBuf;
1904   StringRef PH = PlaceHolder.toStringRef(PHBuf);
1905 
1906   TypePrinter(policy, Indentation).print(ty, qs, OS, PH);
1907 }
1908 
1909 void QualType::getAsStringInternal(std::string &Str,
1910                                    const PrintingPolicy &Policy) const {
1911   return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str,
1912                              Policy);
1913 }
1914 
1915 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
1916                                    std::string &buffer,
1917                                    const PrintingPolicy &policy) {
1918   SmallString<256> Buf;
1919   llvm::raw_svector_ostream StrOS(Buf);
1920   TypePrinter(policy).print(ty, qs, StrOS, buffer);
1921   std::string str = StrOS.str();
1922   buffer.swap(str);
1923 }
1924