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