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