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