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