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_AArch64VectorCall:
865       OS << "__attribute__((aarch64_vector_pcs))";
866       break;
867     case CC_IntelOclBicc:
868       OS << " __attribute__((intel_ocl_bicc))";
869       break;
870     case CC_Win64:
871       OS << " __attribute__((ms_abi))";
872       break;
873     case CC_X86_64SysV:
874       OS << " __attribute__((sysv_abi))";
875       break;
876     case CC_X86RegCall:
877       OS << " __attribute__((regcall))";
878       break;
879     case CC_SpirFunction:
880     case CC_OpenCLKernel:
881       // Do nothing. These CCs are not available as attributes.
882       break;
883     case CC_Swift:
884       OS << " __attribute__((swiftcall))";
885       break;
886     case CC_PreserveMost:
887       OS << " __attribute__((preserve_most))";
888       break;
889     case CC_PreserveAll:
890       OS << " __attribute__((preserve_all))";
891       break;
892     }
893   }
894 
895   if (Info.getNoReturn())
896     OS << " __attribute__((noreturn))";
897   if (Info.getProducesResult())
898     OS << " __attribute__((ns_returns_retained))";
899   if (Info.getRegParm())
900     OS << " __attribute__((regparm ("
901        << Info.getRegParm() << ")))";
902   if (Info.getNoCallerSavedRegs())
903     OS << " __attribute__((no_caller_saved_registers))";
904   if (Info.getNoCfCheck())
905     OS << " __attribute__((nocf_check))";
906 }
907 
908 void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T,
909                                              raw_ostream &OS) {
910   // If needed for precedence reasons, wrap the inner part in grouping parens.
911   SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
912   printBefore(T->getReturnType(), OS);
913   if (!PrevPHIsEmpty.get())
914     OS << '(';
915 }
916 
917 void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T,
918                                             raw_ostream &OS) {
919   // If needed for precedence reasons, wrap the inner part in grouping parens.
920   if (!HasEmptyPlaceHolder)
921     OS << ')';
922   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
923 
924   OS << "()";
925   printFunctionAfter(T->getExtInfo(), OS);
926   printAfter(T->getReturnType(), OS);
927 }
928 
929 void TypePrinter::printTypeSpec(NamedDecl *D, raw_ostream &OS) {
930 
931   // Compute the full nested-name-specifier for this type.
932   // In C, this will always be empty except when the type
933   // being printed is anonymous within other Record.
934   if (!Policy.SuppressScope)
935     AppendScope(D->getDeclContext(), OS);
936 
937   IdentifierInfo *II = D->getIdentifier();
938   OS << II->getName();
939   spaceBeforePlaceHolder(OS);
940 }
941 
942 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
943                                              raw_ostream &OS) {
944   printTypeSpec(T->getDecl(), OS);
945 }
946 
947 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
948                                             raw_ostream &OS) {}
949 
950 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
951   printTypeSpec(T->getDecl(), OS);
952 }
953 
954 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {}
955 
956 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
957                                         raw_ostream &OS) {
958   OS << "typeof ";
959   if (T->getUnderlyingExpr())
960     T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
961   spaceBeforePlaceHolder(OS);
962 }
963 
964 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
965                                        raw_ostream &OS) {}
966 
967 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
968   OS << "typeof(";
969   print(T->getUnderlyingType(), OS, StringRef());
970   OS << ')';
971   spaceBeforePlaceHolder(OS);
972 }
973 
974 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {}
975 
976 void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
977   OS << "decltype(";
978   if (T->getUnderlyingExpr())
979     T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
980   OS << ')';
981   spaceBeforePlaceHolder(OS);
982 }
983 
984 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}
985 
986 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
987                                             raw_ostream &OS) {
988   IncludeStrongLifetimeRAII Strong(Policy);
989 
990   switch (T->getUTTKind()) {
991     case UnaryTransformType::EnumUnderlyingType:
992       OS << "__underlying_type(";
993       print(T->getBaseType(), OS, StringRef());
994       OS << ')';
995       spaceBeforePlaceHolder(OS);
996       return;
997   }
998 
999   printBefore(T->getBaseType(), OS);
1000 }
1001 
1002 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
1003                                            raw_ostream &OS) {
1004   IncludeStrongLifetimeRAII Strong(Policy);
1005 
1006   switch (T->getUTTKind()) {
1007     case UnaryTransformType::EnumUnderlyingType:
1008       return;
1009   }
1010 
1011   printAfter(T->getBaseType(), OS);
1012 }
1013 
1014 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
1015   // If the type has been deduced, do not print 'auto'.
1016   if (!T->getDeducedType().isNull()) {
1017     printBefore(T->getDeducedType(), OS);
1018   } else {
1019     switch (T->getKeyword()) {
1020     case AutoTypeKeyword::Auto: OS << "auto"; break;
1021     case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break;
1022     case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break;
1023     }
1024     spaceBeforePlaceHolder(OS);
1025   }
1026 }
1027 
1028 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
1029   // If the type has been deduced, do not print 'auto'.
1030   if (!T->getDeducedType().isNull())
1031     printAfter(T->getDeducedType(), OS);
1032 }
1033 
1034 void TypePrinter::printDeducedTemplateSpecializationBefore(
1035     const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
1036   // If the type has been deduced, print the deduced type.
1037   if (!T->getDeducedType().isNull()) {
1038     printBefore(T->getDeducedType(), OS);
1039   } else {
1040     IncludeStrongLifetimeRAII Strong(Policy);
1041     T->getTemplateName().print(OS, Policy);
1042     spaceBeforePlaceHolder(OS);
1043   }
1044 }
1045 
1046 void TypePrinter::printDeducedTemplateSpecializationAfter(
1047     const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
1048   // If the type has been deduced, print the deduced type.
1049   if (!T->getDeducedType().isNull())
1050     printAfter(T->getDeducedType(), OS);
1051 }
1052 
1053 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) {
1054   IncludeStrongLifetimeRAII Strong(Policy);
1055 
1056   OS << "_Atomic(";
1057   print(T->getValueType(), OS, StringRef());
1058   OS << ')';
1059   spaceBeforePlaceHolder(OS);
1060 }
1061 
1062 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {}
1063 
1064 void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) {
1065   IncludeStrongLifetimeRAII Strong(Policy);
1066 
1067   if (T->isReadOnly())
1068     OS << "read_only ";
1069   else
1070     OS << "write_only ";
1071   OS << "pipe ";
1072   print(T->getElementType(), OS, StringRef());
1073   spaceBeforePlaceHolder(OS);
1074 }
1075 
1076 void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {}
1077 
1078 /// Appends the given scope to the end of a string.
1079 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) {
1080   if (DC->isTranslationUnit()) return;
1081   if (DC->isFunctionOrMethod()) return;
1082   AppendScope(DC->getParent(), OS);
1083 
1084   if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
1085     if (Policy.SuppressUnwrittenScope &&
1086         (NS->isAnonymousNamespace() || NS->isInline()))
1087       return;
1088     if (NS->getIdentifier())
1089       OS << NS->getName() << "::";
1090     else
1091       OS << "(anonymous namespace)::";
1092   } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1093     IncludeStrongLifetimeRAII Strong(Policy);
1094     OS << Spec->getIdentifier()->getName();
1095     const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1096     printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
1097     OS << "::";
1098   } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) {
1099     if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
1100       OS << Typedef->getIdentifier()->getName() << "::";
1101     else if (Tag->getIdentifier())
1102       OS << Tag->getIdentifier()->getName() << "::";
1103     else
1104       return;
1105   }
1106 }
1107 
1108 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
1109   if (Policy.IncludeTagDefinition) {
1110     PrintingPolicy SubPolicy = Policy;
1111     SubPolicy.IncludeTagDefinition = false;
1112     D->print(OS, SubPolicy, Indentation);
1113     spaceBeforePlaceHolder(OS);
1114     return;
1115   }
1116 
1117   bool HasKindDecoration = false;
1118 
1119   // We don't print tags unless this is an elaborated type.
1120   // In C, we just assume every RecordType is an elaborated type.
1121   if (!Policy.SuppressTagKeyword && !D->getTypedefNameForAnonDecl()) {
1122     HasKindDecoration = true;
1123     OS << D->getKindName();
1124     OS << ' ';
1125   }
1126 
1127   // Compute the full nested-name-specifier for this type.
1128   // In C, this will always be empty except when the type
1129   // being printed is anonymous within other Record.
1130   if (!Policy.SuppressScope)
1131     AppendScope(D->getDeclContext(), OS);
1132 
1133   if (const IdentifierInfo *II = D->getIdentifier())
1134     OS << II->getName();
1135   else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
1136     assert(Typedef->getIdentifier() && "Typedef without identifier?");
1137     OS << Typedef->getIdentifier()->getName();
1138   } else {
1139     // Make an unambiguous representation for anonymous types, e.g.
1140     //   (anonymous enum at /usr/include/string.h:120:9)
1141     OS << (Policy.MSVCFormatting ? '`' : '(');
1142 
1143     if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) {
1144       OS << "lambda";
1145       HasKindDecoration = true;
1146     } else {
1147       OS << "anonymous";
1148     }
1149 
1150     if (Policy.AnonymousTagLocations) {
1151       // Suppress the redundant tag keyword if we just printed one.
1152       // We don't have to worry about ElaboratedTypes here because you can't
1153       // refer to an anonymous type with one.
1154       if (!HasKindDecoration)
1155         OS << " " << D->getKindName();
1156 
1157       PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc(
1158           D->getLocation());
1159       if (PLoc.isValid()) {
1160         OS << " at ";
1161         StringRef File = PLoc.getFilename();
1162         if (Policy.RemapFilePaths)
1163           OS << Policy.remapPath(File);
1164         else
1165           OS << File;
1166         OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
1167       }
1168     }
1169 
1170     OS << (Policy.MSVCFormatting ? '\'' : ')');
1171   }
1172 
1173   // If this is a class template specialization, print the template
1174   // arguments.
1175   if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
1176     ArrayRef<TemplateArgument> Args;
1177     if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
1178       const TemplateSpecializationType *TST =
1179         cast<TemplateSpecializationType>(TAW->getType());
1180       Args = TST->template_arguments();
1181     } else {
1182       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1183       Args = TemplateArgs.asArray();
1184     }
1185     IncludeStrongLifetimeRAII Strong(Policy);
1186     printTemplateArgumentList(OS, Args, Policy);
1187   }
1188 
1189   spaceBeforePlaceHolder(OS);
1190 }
1191 
1192 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
1193   printTag(T->getDecl(), OS);
1194 }
1195 
1196 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {}
1197 
1198 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
1199   printTag(T->getDecl(), OS);
1200 }
1201 
1202 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {}
1203 
1204 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
1205                                               raw_ostream &OS) {
1206   if (IdentifierInfo *Id = T->getIdentifier())
1207     OS << Id->getName();
1208   else
1209     OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
1210   spaceBeforePlaceHolder(OS);
1211 }
1212 
1213 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
1214                                              raw_ostream &OS) {}
1215 
1216 void TypePrinter::printSubstTemplateTypeParmBefore(
1217                                              const SubstTemplateTypeParmType *T,
1218                                              raw_ostream &OS) {
1219   IncludeStrongLifetimeRAII Strong(Policy);
1220   printBefore(T->getReplacementType(), OS);
1221 }
1222 
1223 void TypePrinter::printSubstTemplateTypeParmAfter(
1224                                              const SubstTemplateTypeParmType *T,
1225                                              raw_ostream &OS) {
1226   IncludeStrongLifetimeRAII Strong(Policy);
1227   printAfter(T->getReplacementType(), OS);
1228 }
1229 
1230 void TypePrinter::printSubstTemplateTypeParmPackBefore(
1231                                         const SubstTemplateTypeParmPackType *T,
1232                                         raw_ostream &OS) {
1233   IncludeStrongLifetimeRAII Strong(Policy);
1234   printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1235 }
1236 
1237 void TypePrinter::printSubstTemplateTypeParmPackAfter(
1238                                         const SubstTemplateTypeParmPackType *T,
1239                                         raw_ostream &OS) {
1240   IncludeStrongLifetimeRAII Strong(Policy);
1241   printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1242 }
1243 
1244 void TypePrinter::printTemplateSpecializationBefore(
1245                                             const TemplateSpecializationType *T,
1246                                             raw_ostream &OS) {
1247   IncludeStrongLifetimeRAII Strong(Policy);
1248   T->getTemplateName().print(OS, Policy);
1249 
1250   printTemplateArgumentList(OS, T->template_arguments(), Policy);
1251   spaceBeforePlaceHolder(OS);
1252 }
1253 
1254 void TypePrinter::printTemplateSpecializationAfter(
1255                                             const TemplateSpecializationType *T,
1256                                             raw_ostream &OS) {}
1257 
1258 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
1259                                                raw_ostream &OS) {
1260   printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1261 }
1262 
1263 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
1264                                                raw_ostream &OS) {}
1265 
1266 void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
1267                                         raw_ostream &OS) {
1268   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) {
1269     TagDecl *OwnedTagDecl = T->getOwnedTagDecl();
1270     assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() &&
1271            "OwnedTagDecl expected to be a declaration for the type");
1272     PrintingPolicy SubPolicy = Policy;
1273     SubPolicy.IncludeTagDefinition = false;
1274     OwnedTagDecl->print(OS, SubPolicy, Indentation);
1275     spaceBeforePlaceHolder(OS);
1276     return;
1277   }
1278 
1279   // The tag definition will take care of these.
1280   if (!Policy.IncludeTagDefinition)
1281   {
1282     OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1283     if (T->getKeyword() != ETK_None)
1284       OS << " ";
1285     NestedNameSpecifier *Qualifier = T->getQualifier();
1286     if (Qualifier)
1287       Qualifier->print(OS, Policy);
1288   }
1289 
1290   ElaboratedTypePolicyRAII PolicyRAII(Policy);
1291   printBefore(T->getNamedType(), OS);
1292 }
1293 
1294 void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
1295                                         raw_ostream &OS) {
1296   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl())
1297     return;
1298   ElaboratedTypePolicyRAII PolicyRAII(Policy);
1299   printAfter(T->getNamedType(), OS);
1300 }
1301 
1302 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
1303   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1304     printBefore(T->getInnerType(), OS);
1305     OS << '(';
1306   } else
1307     printBefore(T->getInnerType(), OS);
1308 }
1309 
1310 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
1311   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1312     OS << ')';
1313     printAfter(T->getInnerType(), OS);
1314   } else
1315     printAfter(T->getInnerType(), OS);
1316 }
1317 
1318 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
1319                                            raw_ostream &OS) {
1320   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1321   if (T->getKeyword() != ETK_None)
1322     OS << " ";
1323 
1324   T->getQualifier()->print(OS, Policy);
1325 
1326   OS << T->getIdentifier()->getName();
1327   spaceBeforePlaceHolder(OS);
1328 }
1329 
1330 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
1331                                           raw_ostream &OS) {}
1332 
1333 void TypePrinter::printDependentTemplateSpecializationBefore(
1334         const DependentTemplateSpecializationType *T, raw_ostream &OS) {
1335   IncludeStrongLifetimeRAII Strong(Policy);
1336 
1337   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1338   if (T->getKeyword() != ETK_None)
1339     OS << " ";
1340 
1341   if (T->getQualifier())
1342     T->getQualifier()->print(OS, Policy);
1343   OS << T->getIdentifier()->getName();
1344   printTemplateArgumentList(OS, T->template_arguments(), Policy);
1345   spaceBeforePlaceHolder(OS);
1346 }
1347 
1348 void TypePrinter::printDependentTemplateSpecializationAfter(
1349         const DependentTemplateSpecializationType *T, raw_ostream &OS) {}
1350 
1351 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
1352                                            raw_ostream &OS) {
1353   printBefore(T->getPattern(), OS);
1354 }
1355 
1356 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
1357                                           raw_ostream &OS) {
1358   printAfter(T->getPattern(), OS);
1359   OS << "...";
1360 }
1361 
1362 void TypePrinter::printAttributedBefore(const AttributedType *T,
1363                                         raw_ostream &OS) {
1364   // FIXME: Generate this with TableGen.
1365 
1366   // Prefer the macro forms of the GC and ownership qualifiers.
1367   if (T->getAttrKind() == attr::ObjCGC ||
1368       T->getAttrKind() == attr::ObjCOwnership)
1369     return printBefore(T->getEquivalentType(), OS);
1370 
1371   if (T->getAttrKind() == attr::ObjCKindOf)
1372     OS << "__kindof ";
1373 
1374   printBefore(T->getModifiedType(), OS);
1375 
1376   if (T->isMSTypeSpec()) {
1377     switch (T->getAttrKind()) {
1378     default: return;
1379     case attr::Ptr32: OS << " __ptr32"; break;
1380     case attr::Ptr64: OS << " __ptr64"; break;
1381     case attr::SPtr: OS << " __sptr"; break;
1382     case attr::UPtr: OS << " __uptr"; break;
1383     }
1384     spaceBeforePlaceHolder(OS);
1385   }
1386 
1387   // Print nullability type specifiers.
1388   if (T->getImmediateNullability()) {
1389     if (T->getAttrKind() == attr::TypeNonNull)
1390       OS << " _Nonnull";
1391     else if (T->getAttrKind() == attr::TypeNullable)
1392       OS << " _Nullable";
1393     else if (T->getAttrKind() == attr::TypeNullUnspecified)
1394       OS << " _Null_unspecified";
1395     else
1396       llvm_unreachable("unhandled nullability");
1397     spaceBeforePlaceHolder(OS);
1398   }
1399 }
1400 
1401 void TypePrinter::printAttributedAfter(const AttributedType *T,
1402                                        raw_ostream &OS) {
1403   // FIXME: Generate this with TableGen.
1404 
1405   // Prefer the macro forms of the GC and ownership qualifiers.
1406   if (T->getAttrKind() == attr::ObjCGC ||
1407       T->getAttrKind() == attr::ObjCOwnership)
1408     return printAfter(T->getEquivalentType(), OS);
1409 
1410   // If this is a calling convention attribute, don't print the implicit CC from
1411   // the modified type.
1412   SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv());
1413 
1414   printAfter(T->getModifiedType(), OS);
1415 
1416   // Some attributes are printed as qualifiers before the type, so we have
1417   // nothing left to do.
1418   if (T->getAttrKind() == attr::ObjCKindOf ||
1419       T->isMSTypeSpec() || T->getImmediateNullability())
1420     return;
1421 
1422   // Don't print the inert __unsafe_unretained attribute at all.
1423   if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained)
1424     return;
1425 
1426   // Don't print ns_returns_retained unless it had an effect.
1427   if (T->getAttrKind() == attr::NSReturnsRetained &&
1428       !T->getEquivalentType()->castAs<FunctionType>()
1429                              ->getExtInfo().getProducesResult())
1430     return;
1431 
1432   if (T->getAttrKind() == attr::LifetimeBound) {
1433     OS << " [[clang::lifetimebound]]";
1434     return;
1435   }
1436 
1437   // The printing of the address_space attribute is handled by the qualifier
1438   // since it is still stored in the qualifier. Return early to prevent printing
1439   // this twice.
1440   if (T->getAttrKind() == attr::AddressSpace)
1441     return;
1442 
1443   OS << " __attribute__((";
1444   switch (T->getAttrKind()) {
1445 #define TYPE_ATTR(NAME)
1446 #define DECL_OR_TYPE_ATTR(NAME)
1447 #define ATTR(NAME) case attr::NAME:
1448 #include "clang/Basic/AttrList.inc"
1449     llvm_unreachable("non-type attribute attached to type");
1450 
1451   case attr::OpenCLPrivateAddressSpace:
1452   case attr::OpenCLGlobalAddressSpace:
1453   case attr::OpenCLLocalAddressSpace:
1454   case attr::OpenCLConstantAddressSpace:
1455   case attr::OpenCLGenericAddressSpace:
1456     // FIXME: Update printAttributedBefore to print these once we generate
1457     // AttributedType nodes for them.
1458     break;
1459 
1460   case attr::LifetimeBound:
1461   case attr::TypeNonNull:
1462   case attr::TypeNullable:
1463   case attr::TypeNullUnspecified:
1464   case attr::ObjCGC:
1465   case attr::ObjCInertUnsafeUnretained:
1466   case attr::ObjCKindOf:
1467   case attr::ObjCOwnership:
1468   case attr::Ptr32:
1469   case attr::Ptr64:
1470   case attr::SPtr:
1471   case attr::UPtr:
1472   case attr::AddressSpace:
1473     llvm_unreachable("This attribute should have been handled already");
1474 
1475   case attr::NSReturnsRetained:
1476     OS << "ns_returns_retained";
1477     break;
1478 
1479   // FIXME: When Sema learns to form this AttributedType, avoid printing the
1480   // attribute again in printFunctionProtoAfter.
1481   case attr::AnyX86NoCfCheck: OS << "nocf_check"; break;
1482   case attr::CDecl: OS << "cdecl"; break;
1483   case attr::FastCall: OS << "fastcall"; break;
1484   case attr::StdCall: OS << "stdcall"; break;
1485   case attr::ThisCall: OS << "thiscall"; break;
1486   case attr::SwiftCall: OS << "swiftcall"; break;
1487   case attr::VectorCall: OS << "vectorcall"; break;
1488   case attr::Pascal: OS << "pascal"; break;
1489   case attr::MSABI: OS << "ms_abi"; break;
1490   case attr::SysVABI: OS << "sysv_abi"; break;
1491   case attr::RegCall: OS << "regcall"; break;
1492   case attr::Pcs: {
1493     OS << "pcs(";
1494    QualType t = T->getEquivalentType();
1495    while (!t->isFunctionType())
1496      t = t->getPointeeType();
1497    OS << (t->getAs<FunctionType>()->getCallConv() == CC_AAPCS ?
1498          "\"aapcs\"" : "\"aapcs-vfp\"");
1499    OS << ')';
1500    break;
1501   }
1502   case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break;
1503   case attr::IntelOclBicc: OS << "inteloclbicc"; break;
1504   case attr::PreserveMost:
1505     OS << "preserve_most";
1506     break;
1507 
1508   case attr::PreserveAll:
1509     OS << "preserve_all";
1510     break;
1511   case attr::NoDeref:
1512     OS << "noderef";
1513     break;
1514   }
1515   OS << "))";
1516 }
1517 
1518 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
1519                                            raw_ostream &OS) {
1520   OS << T->getDecl()->getName();
1521   spaceBeforePlaceHolder(OS);
1522 }
1523 
1524 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
1525                                           raw_ostream &OS) {}
1526 
1527 void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T,
1528                                           raw_ostream &OS) {
1529   OS << T->getDecl()->getName();
1530   if (!T->qual_empty()) {
1531     bool isFirst = true;
1532     OS << '<';
1533     for (const auto *I : T->quals()) {
1534       if (isFirst)
1535         isFirst = false;
1536       else
1537         OS << ',';
1538       OS << I->getName();
1539     }
1540     OS << '>';
1541   }
1542 
1543   spaceBeforePlaceHolder(OS);
1544 }
1545 
1546 void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T,
1547                                           raw_ostream &OS) {}
1548 
1549 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
1550                                         raw_ostream &OS) {
1551   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1552       !T->isKindOfTypeAsWritten())
1553     return printBefore(T->getBaseType(), OS);
1554 
1555   if (T->isKindOfTypeAsWritten())
1556     OS << "__kindof ";
1557 
1558   print(T->getBaseType(), OS, StringRef());
1559 
1560   if (T->isSpecializedAsWritten()) {
1561     bool isFirst = true;
1562     OS << '<';
1563     for (auto typeArg : T->getTypeArgsAsWritten()) {
1564       if (isFirst)
1565         isFirst = false;
1566       else
1567         OS << ",";
1568 
1569       print(typeArg, OS, StringRef());
1570     }
1571     OS << '>';
1572   }
1573 
1574   if (!T->qual_empty()) {
1575     bool isFirst = true;
1576     OS << '<';
1577     for (const auto *I : T->quals()) {
1578       if (isFirst)
1579         isFirst = false;
1580       else
1581         OS << ',';
1582       OS << I->getName();
1583     }
1584     OS << '>';
1585   }
1586 
1587   spaceBeforePlaceHolder(OS);
1588 }
1589 
1590 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
1591                                         raw_ostream &OS) {
1592   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1593       !T->isKindOfTypeAsWritten())
1594     return printAfter(T->getBaseType(), OS);
1595 }
1596 
1597 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
1598                                                raw_ostream &OS) {
1599   printBefore(T->getPointeeType(), OS);
1600 
1601   // If we need to print the pointer, print it now.
1602   if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() &&
1603       !T->isObjCClassType() && !T->isObjCQualifiedClassType()) {
1604     if (HasEmptyPlaceHolder)
1605       OS << ' ';
1606     OS << '*';
1607   }
1608 }
1609 
1610 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
1611                                               raw_ostream &OS) {}
1612 
1613 static
1614 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
1615 
1616 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
1617   return A.getArgument();
1618 }
1619 
1620 template<typename TA>
1621 static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
1622                     const PrintingPolicy &Policy, bool SkipBrackets) {
1623   const char *Comma = Policy.MSVCFormatting ? "," : ", ";
1624   if (!SkipBrackets)
1625     OS << '<';
1626 
1627   bool NeedSpace = false;
1628   bool FirstArg = true;
1629   for (const auto &Arg : Args) {
1630     // Print the argument into a string.
1631     SmallString<128> Buf;
1632     llvm::raw_svector_ostream ArgOS(Buf);
1633     const TemplateArgument &Argument = getArgument(Arg);
1634     if (Argument.getKind() == TemplateArgument::Pack) {
1635       if (Argument.pack_size() && !FirstArg)
1636         OS << Comma;
1637       printTo(ArgOS, Argument.getPackAsArray(), Policy, true);
1638     } else {
1639       if (!FirstArg)
1640         OS << Comma;
1641       Argument.print(Policy, ArgOS);
1642     }
1643     StringRef ArgString = ArgOS.str();
1644 
1645     // If this is the first argument and its string representation
1646     // begins with the global scope specifier ('::foo'), add a space
1647     // to avoid printing the diagraph '<:'.
1648     if (FirstArg && !ArgString.empty() && ArgString[0] == ':')
1649       OS << ' ';
1650 
1651     OS << ArgString;
1652 
1653     NeedSpace = (!ArgString.empty() && ArgString.back() == '>');
1654     FirstArg = false;
1655   }
1656 
1657   // If the last character of our string is '>', add another space to
1658   // keep the two '>''s separate tokens. We don't *have* to do this in
1659   // C++0x, but it's still good hygiene.
1660   if (NeedSpace)
1661     OS << ' ';
1662 
1663   if (!SkipBrackets)
1664     OS << '>';
1665 }
1666 
1667 void clang::printTemplateArgumentList(raw_ostream &OS,
1668                                       const TemplateArgumentListInfo &Args,
1669                                       const PrintingPolicy &Policy) {
1670   return printTo(OS, Args.arguments(), Policy, false);
1671 }
1672 
1673 void clang::printTemplateArgumentList(raw_ostream &OS,
1674                                       ArrayRef<TemplateArgument> Args,
1675                                       const PrintingPolicy &Policy) {
1676   printTo(OS, Args, Policy, false);
1677 }
1678 
1679 void clang::printTemplateArgumentList(raw_ostream &OS,
1680                                       ArrayRef<TemplateArgumentLoc> Args,
1681                                       const PrintingPolicy &Policy) {
1682   printTo(OS, Args, Policy, false);
1683 }
1684 
1685 std::string Qualifiers::getAsString() const {
1686   LangOptions LO;
1687   return getAsString(PrintingPolicy(LO));
1688 }
1689 
1690 // Appends qualifiers to the given string, separated by spaces.  Will
1691 // prefix a space if the string is non-empty.  Will not append a final
1692 // space.
1693 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
1694   SmallString<64> Buf;
1695   llvm::raw_svector_ostream StrOS(Buf);
1696   print(StrOS, Policy);
1697   return StrOS.str();
1698 }
1699 
1700 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
1701   if (getCVRQualifiers())
1702     return false;
1703 
1704   if (getAddressSpace() != LangAS::Default)
1705     return false;
1706 
1707   if (getObjCGCAttr())
1708     return false;
1709 
1710   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
1711     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
1712       return false;
1713 
1714   return true;
1715 }
1716 
1717 // Appends qualifiers to the given string, separated by spaces.  Will
1718 // prefix a space if the string is non-empty.  Will not append a final
1719 // space.
1720 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
1721                        bool appendSpaceIfNonEmpty) const {
1722   bool addSpace = false;
1723 
1724   unsigned quals = getCVRQualifiers();
1725   if (quals) {
1726     AppendTypeQualList(OS, quals, Policy.Restrict);
1727     addSpace = true;
1728   }
1729   if (hasUnaligned()) {
1730     if (addSpace)
1731       OS << ' ';
1732     OS << "__unaligned";
1733     addSpace = true;
1734   }
1735   LangAS addrspace = getAddressSpace();
1736   if (addrspace != LangAS::Default) {
1737     if (addrspace != LangAS::opencl_private) {
1738       if (addSpace)
1739         OS << ' ';
1740       addSpace = true;
1741       switch (addrspace) {
1742       case LangAS::opencl_global:
1743         OS << "__global";
1744         break;
1745       case LangAS::opencl_local:
1746         OS << "__local";
1747         break;
1748       case LangAS::opencl_private:
1749         break;
1750       case LangAS::opencl_constant:
1751       case LangAS::cuda_constant:
1752         OS << "__constant";
1753         break;
1754       case LangAS::opencl_generic:
1755         OS << "__generic";
1756         break;
1757       case LangAS::cuda_device:
1758         OS << "__device";
1759         break;
1760       case LangAS::cuda_shared:
1761         OS << "__shared";
1762         break;
1763       default:
1764         OS << "__attribute__((address_space(";
1765         OS << toTargetAddressSpace(addrspace);
1766         OS << ")))";
1767       }
1768     }
1769   }
1770   if (Qualifiers::GC gc = getObjCGCAttr()) {
1771     if (addSpace)
1772       OS << ' ';
1773     addSpace = true;
1774     if (gc == Qualifiers::Weak)
1775       OS << "__weak";
1776     else
1777       OS << "__strong";
1778   }
1779   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
1780     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
1781       if (addSpace)
1782         OS << ' ';
1783       addSpace = true;
1784     }
1785 
1786     switch (lifetime) {
1787     case Qualifiers::OCL_None: llvm_unreachable("none but true");
1788     case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
1789     case Qualifiers::OCL_Strong:
1790       if (!Policy.SuppressStrongLifetime)
1791         OS << "__strong";
1792       break;
1793 
1794     case Qualifiers::OCL_Weak: OS << "__weak"; break;
1795     case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
1796     }
1797   }
1798 
1799   if (appendSpaceIfNonEmpty && addSpace)
1800     OS << ' ';
1801 }
1802 
1803 std::string QualType::getAsString() const {
1804   return getAsString(split(), LangOptions());
1805 }
1806 
1807 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
1808   std::string S;
1809   getAsStringInternal(S, Policy);
1810   return S;
1811 }
1812 
1813 std::string QualType::getAsString(const Type *ty, Qualifiers qs,
1814                                   const PrintingPolicy &Policy) {
1815   std::string buffer;
1816   getAsStringInternal(ty, qs, buffer, Policy);
1817   return buffer;
1818 }
1819 
1820 void QualType::print(const Type *ty, Qualifiers qs,
1821                      raw_ostream &OS, const PrintingPolicy &policy,
1822                      const Twine &PlaceHolder, unsigned Indentation) {
1823   SmallString<128> PHBuf;
1824   StringRef PH = PlaceHolder.toStringRef(PHBuf);
1825 
1826   TypePrinter(policy, Indentation).print(ty, qs, OS, PH);
1827 }
1828 
1829 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
1830                                    std::string &buffer,
1831                                    const PrintingPolicy &policy) {
1832   SmallString<256> Buf;
1833   llvm::raw_svector_ostream StrOS(Buf);
1834   TypePrinter(policy).print(ty, qs, StrOS, buffer);
1835   std::string str = StrOS.str();
1836   buffer.swap(str);
1837 }
1838