clang  10.0.0git
TypePrinter.cpp
Go to the documentation of this file.
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 
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"
22 #include "clang/AST/TemplateBase.h"
23 #include "clang/AST/TemplateName.h"
24 #include "clang/AST/Type.h"
28 #include "clang/Basic/LLVM.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 
45 using namespace clang;
46 
47 namespace {
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 
137 static 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 
159 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) {
160  if (!HasEmptyPlaceHolder)
161  OS << ' ';
162 }
163 
165  const PrintingPolicy &Policy) {
166  if (Policy.PrintCanonicalTypes)
167  QT = QT.getCanonicalType();
168  return QT.split();
169 }
170 
171 void 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 
176 void 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 
190 bool 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() ||
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 
277 void TypePrinter::printBefore(QualType T, raw_ostream &OS) {
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 ".
291 void 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 
337 void 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]".
344 void 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 
354 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) {
355  OS << T->getName(Policy);
356  spaceBeforePlaceHolder(OS);
357 }
358 
359 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {}
360 
361 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) {
362  OS << "_Complex ";
363  printBefore(T->getElementType(), OS);
364 }
365 
366 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) {
367  printAfter(T->getElementType(), OS);
368 }
369 
370 void 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 
381 void 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 
391 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T,
392  raw_ostream &OS) {
393  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
394  printBefore(T->getPointeeType(), OS);
395  OS << '^';
396 }
397 
398 void 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.
407  if (auto *Ref = T->getAs<ReferenceType>())
408  return skipTopLevelReferences(Ref->getPointeeTypeAsWritten());
409  return T;
410 }
411 
412 void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T,
413  raw_ostream &OS) {
414  IncludeStrongLifetimeRAII Strong(Policy);
415  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
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 
425 void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T,
426  raw_ostream &OS) {
427  IncludeStrongLifetimeRAII Strong(Policy);
428  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
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 
437 void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T,
438  raw_ostream &OS) {
439  IncludeStrongLifetimeRAII Strong(Policy);
440  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
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 
450 void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T,
451  raw_ostream &OS) {
452  IncludeStrongLifetimeRAII Strong(Policy);
453  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
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 
462 void 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 
479 void 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 
490 void 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 
497 void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
498  raw_ostream &OS) {
499  OS << '[';
502  Policy.Restrict);
503  OS << ' ';
504  }
505 
507  OS << "static ";
508 
509  OS << T->getSize().getZExtValue() << ']';
510  printAfter(T->getElementType(), OS);
511 }
512 
513 void 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 
520 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
521  raw_ostream &OS) {
522  OS << "[]";
523  printAfter(T->getElementType(), OS);
524 }
525 
526 void 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 
533 void TypePrinter::printVariableArrayAfter(const VariableArrayType *T,
534  raw_ostream &OS) {
535  OS << '[';
537  AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.Restrict);
538  OS << ' ';
539  }
540 
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 
553 void 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 
559 void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) {
560  printAfter(T->getAdjustedType(), OS);
561 }
562 
563 void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) {
564  // Print as though it's a pointer.
565  printAdjustedBefore(T, OS);
566 }
567 
568 void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) {
569  printAdjustedAfter(T, OS);
570 }
571 
572 void 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 
580 void 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 
590 void TypePrinter::printDependentAddressSpaceBefore(
591  const DependentAddressSpaceType *T, raw_ostream &OS) {
592  printBefore(T->getPointeeType(), OS);
593 }
594 
595 void 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 
604 void TypePrinter::printDependentSizedExtVectorBefore(
606  raw_ostream &OS) {
607  printBefore(T->getElementType(), OS);
608 }
609 
610 void TypePrinter::printDependentSizedExtVectorAfter(
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 
620 void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) {
621  switch (T->getVectorKind()) {
623  OS << "__vector __pixel ";
624  break;
626  OS << "__vector __bool ";
627  printBefore(T->getElementType(), OS);
628  break;
630  OS << "__vector ";
631  printBefore(T->getElementType(), OS);
632  break;
634  OS << "__attribute__((neon_vector_type("
635  << T->getNumElements() << "))) ";
636  printBefore(T->getElementType(), OS);
637  break;
639  OS << "__attribute__((neon_polyvector_type(" <<
640  T->getNumElements() << "))) ";
641  printBefore(T->getElementType(), OS);
642  break;
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 
657 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) {
658  printAfter(T->getElementType(), OS);
659 }
660 
661 void TypePrinter::printDependentVectorBefore(
662  const DependentVectorType *T, raw_ostream &OS) {
663  switch (T->getVectorKind()) {
665  OS << "__vector __pixel ";
666  break;
668  OS << "__vector __bool ";
669  printBefore(T->getElementType(), OS);
670  break;
672  OS << "__vector ";
673  printBefore(T->getElementType(), OS);
674  break;
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;
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;
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 
704 void TypePrinter::printDependentVectorAfter(
705  const DependentVectorType *T, raw_ostream &OS) {
706  printAfter(T->getElementType(), OS);
707 }
708 
709 void TypePrinter::printExtVectorBefore(const ExtVectorType *T,
710  raw_ostream &OS) {
711  printBefore(T->getElementType(), OS);
712 }
713 
714 void 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 
721 void
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 
752 void 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 
768  switch (ABI) {
770  llvm_unreachable("asking for spelling of ordinary parameter ABI");
772  return "swift_context";
774  return "swift_error_result";
776  return "swift_indirect_result";
777  }
778  llvm_unreachable("bad parameter ABI kind");
779 }
780 
781 void 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 
845 void 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;
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 
923 void 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 
932 void 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 
944 void 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 
957 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
958  raw_ostream &OS) {
959  printTypeSpec(T->getDecl(), OS);
960 }
961 
962 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
963  raw_ostream &OS) {}
964 
965 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
966  printTypeSpec(T->getDecl(), OS);
967 }
968 
969 void 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 
979 void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T,
980  raw_ostream &OS) {
981  printAfter(T->getModifiedType(), OS);
982 }
983 
984 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {}
985 
986 void 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 
994 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
995  raw_ostream &OS) {}
996 
997 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
998  OS << "typeof(";
999  print(T->getUnderlyingType(), OS, StringRef());
1000  OS << ')';
1001  spaceBeforePlaceHolder(OS);
1002 }
1003 
1004 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {}
1005 
1006 void 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 
1014 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}
1015 
1016 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
1017  raw_ostream &OS) {
1018  IncludeStrongLifetimeRAII Strong(Policy);
1019 
1020  switch (T->getUTTKind()) {
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 
1032 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
1033  raw_ostream &OS) {
1034  IncludeStrongLifetimeRAII Strong(Policy);
1035 
1036  switch (T->getUTTKind()) {
1038  return;
1039  }
1040 
1041  printAfter(T->getBaseType(), OS);
1042 }
1043 
1044 void 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 
1065 void 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 
1071 void 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 
1083 void 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 
1090 void 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 
1099 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {}
1100 
1101 void 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 
1113 void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {}
1114 
1115 /// Appends the given scope to the end of a string.
1116 void 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 
1145 void 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 
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)) {
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 
1230 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
1231  printTag(T->getDecl(), OS);
1232 }
1233 
1234 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {}
1235 
1236 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
1237  printTag(T->getDecl(), OS);
1238 }
1239 
1240 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {}
1241 
1242 void 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 
1259 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
1260  raw_ostream &OS) {}
1261 
1262 void TypePrinter::printSubstTemplateTypeParmBefore(
1263  const SubstTemplateTypeParmType *T,
1264  raw_ostream &OS) {
1265  IncludeStrongLifetimeRAII Strong(Policy);
1266  printBefore(T->getReplacementType(), OS);
1267 }
1268 
1269 void TypePrinter::printSubstTemplateTypeParmAfter(
1270  const SubstTemplateTypeParmType *T,
1271  raw_ostream &OS) {
1272  IncludeStrongLifetimeRAII Strong(Policy);
1273  printAfter(T->getReplacementType(), OS);
1274 }
1275 
1276 void TypePrinter::printSubstTemplateTypeParmPackBefore(
1278  raw_ostream &OS) {
1279  IncludeStrongLifetimeRAII Strong(Policy);
1280  printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1281 }
1282 
1283 void TypePrinter::printSubstTemplateTypeParmPackAfter(
1285  raw_ostream &OS) {
1286  IncludeStrongLifetimeRAII Strong(Policy);
1287  printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1288 }
1289 
1290 void TypePrinter::printTemplateSpecializationBefore(
1291  const TemplateSpecializationType *T,
1292  raw_ostream &OS) {
1293  IncludeStrongLifetimeRAII Strong(Policy);
1294  T->getTemplateName().print(OS, Policy);
1295 
1297  spaceBeforePlaceHolder(OS);
1298 }
1299 
1300 void TypePrinter::printTemplateSpecializationAfter(
1301  const TemplateSpecializationType *T,
1302  raw_ostream &OS) {}
1303 
1304 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
1305  raw_ostream &OS) {
1306  printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1307 }
1308 
1309 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
1310  raw_ostream &OS) {}
1311 
1312 void 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  {
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 
1340 void 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 
1348 void 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 
1356 void 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 
1364 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
1365  raw_ostream &OS) {
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 
1376 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
1377  raw_ostream &OS) {}
1378 
1379 void TypePrinter::printDependentTemplateSpecializationBefore(
1380  const DependentTemplateSpecializationType *T, raw_ostream &OS) {
1381  IncludeStrongLifetimeRAII Strong(Policy);
1382 
1384  if (T->getKeyword() != ETK_None)
1385  OS << " ";
1386 
1387  if (T->getQualifier())
1388  T->getQualifier()->print(OS, Policy);
1389  OS << T->getIdentifier()->getName();
1391  spaceBeforePlaceHolder(OS);
1392 }
1393 
1394 void TypePrinter::printDependentTemplateSpecializationAfter(
1395  const DependentTemplateSpecializationType *T, raw_ostream &OS) {}
1396 
1397 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
1398  raw_ostream &OS) {
1399  printBefore(T->getPattern(), OS);
1400 }
1401 
1402 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
1403  raw_ostream &OS) {
1404  printAfter(T->getPattern(), OS);
1405  OS << "...";
1406 }
1407 
1408 void 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 
1450 void 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 ||
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 &&
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 
1570 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
1571  raw_ostream &OS) {
1572  OS << T->getDecl()->getName();
1573  spaceBeforePlaceHolder(OS);
1574 }
1575 
1576 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
1577  raw_ostream &OS) {}
1578 
1579 void 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 
1598 void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T,
1599  raw_ostream &OS) {}
1600 
1601 void 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 
1642 void 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 
1649 void 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 
1662 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
1663  raw_ostream &OS) {}
1664 
1665 static
1666 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
1667 
1668 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
1669  return A.getArgument();
1670 }
1671 
1672 static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP,
1673  llvm::raw_ostream &OS) {
1674  A.print(PP, OS);
1675 }
1676 
1677 static 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 
1685 template<typename TA>
1686 static 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 
1733 void clang::printTemplateArgumentList(raw_ostream &OS,
1734  const TemplateArgumentListInfo &Args,
1735  const PrintingPolicy &Policy) {
1736  return printTo(OS, Args.arguments(), Policy, false);
1737 }
1738 
1739 void clang::printTemplateArgumentList(raw_ostream &OS,
1740  ArrayRef<TemplateArgument> Args,
1741  const PrintingPolicy &Policy) {
1742  printTo(OS, Args, Policy, false);
1743 }
1744 
1745 void clang::printTemplateArgumentList(raw_ostream &OS,
1746  ArrayRef<TemplateArgumentLoc> Args,
1747  const PrintingPolicy &Policy) {
1748  printTo(OS, Args, Policy, false);
1749 }
1750 
1751 std::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.
1759 std::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 
1766 bool 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 
1783 std::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.
1817 void 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 
1877 std::string QualType::getAsString() const {
1878  return getAsString(split(), LangOptions());
1879 }
1880 
1881 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
1882  std::string S;
1883  getAsStringInternal(S, Policy);
1884  return S;
1885 }
1886 
1887 std::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 
1894 void 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 
1900 void 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 
1909 void QualType::getAsStringInternal(std::string &Str,
1910  const PrintingPolicy &Policy) const {
1911  return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str,
1912  Policy);
1913 }
1914 
1915 void 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 }
static StringRef getKeywordName(ElaboratedTypeKeyword Keyword)
Definition: Type.cpp:2687
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:5532
Defines the clang::ASTContext interface.
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it&#39;s either not been deduced or was deduce...
Definition: Type.h:4859
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:5285
const Type * Ty
The locally-unqualified type.
Definition: Type.h:595
static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals, bool HasRestrictKeyword)
const TemplateSpecializationType * getInjectedTST() const
Definition: Type.h:5168
StringRef getName(const PrintingPolicy &Policy) const
Definition: Type.cpp:2761
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:4112
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
QualType getElementType() const
Definition: Type.h:6173
QualType getPointeeType() const
Definition: Type.h:2627
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:4210
A (possibly-)qualified type.
Definition: Type.h:654
bool getNoCfCheck() const
Definition: Type.h:3582
__auto_type (GNU extension)
ArrayRef< TemplateArgument > getTypeConstraintArguments() const
Definition: Type.h:4904
Expr * getUnderlyingExpr() const
Definition: Type.h:4380
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3422
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:557
C Language Family Type Representation.
Defines the SourceManager interface.
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:5368
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5387
const Type * getTypeForDecl() const
Definition: Decl.h:3053
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4086
Defines the C++ template declaration subclasses.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: Type.h:4874
The base class of the type hierarchy.
Definition: Type.h:1450
A container of type source information.
Definition: Type.h:6227
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:6140
TemplateTypeParmDecl * getDecl() const
Definition: Type.h:4694
void printExceptionSpecification(raw_ostream &OS, const PrintingPolicy &Policy) const
QualType getElementType() const
Definition: Type.h:2910
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
Definition: Type.h:4958
unsigned getNumParams() const
Definition: Type.h:3964
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
Represents a C++17 deduced template specialization type.
Definition: Type.h:4940
bool isCallingConv() const
Definition: Type.cpp:3362
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:47
void print(llvm::raw_ostream &OS, const Pointer &P, ASTContext &Ctx, QualType Ty)
Definition: InterpFrame.cpp:62
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4728
The collection of all-type qualifiers we support.
Definition: Type.h:143
bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType)
PipeType - OpenCL20.
Definition: Type.h:6159
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:244
One of these records is kept for each identifier that is lexed.
unsigned SuppressLifetimeQualifiers
When true, suppress printing of lifetime qualifier in ARC.
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool SuppressNNS=false) const
Print the template name.
unsigned getRegParm() const
Definition: Type.h:3585
void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const
QualType getPointeeType() const
Definition: Type.h:2731
is ARM Neon vector
Definition: Type.h:3251
bool isObjCIdType() const
Definition: Type.h:6651
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:5059
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
const IdentifierInfo * getMacroIdentifier() const
Definition: Type.h:4284
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4784
TagDecl * getOwnedTagDecl() const
Return the (re)declaration of this type owned by this occurrence of this type, or nullptr if there is...
Definition: Type.h:5335
bool isObjCQualifiedClassType() const
Definition: Type.h:6645
QualType getModifiedType() const
Return this attributed type&#39;s modified type with no qualifiers attached to it.
Definition: Type.cpp:3203
unsigned SuppressStrongLifetime
When true, suppress printing of the __strong lifetime qualifier in ARC.
bool getProducesResult() const
Definition: Type.h:3580
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment...
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2815
UnresolvedUsingTypenameDecl * getDecl() const
Definition: Type.h:4221
bool isMSTypeSpec() const
Definition: Type.cpp:3349
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1406
Microsoft throw(...) extension.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
bool isConstrained() const
Definition: Type.h:4912
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation...
Definition: Type.h:4266
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4300
const Type * getClass() const
Definition: Type.h:2867
Expr * getSizeExpr() const
Definition: Type.h:3058
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6256
bool getNoReturn() const
Definition: Type.h:3579
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false) const
Print this nested name specifier to the given output stream.
is ARM Neon polynomial vector
Definition: Type.h:3254
Expr * getSizeExpr() const
Definition: Type.h:3115
bool getNoCallerSavedRegs() const
Definition: Type.h:3581
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2769
Expr * getSizeExpr() const
Definition: Type.h:3325
QualType getElementType() const
Definition: Type.h:3211
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
unsigned PrintCanonicalTypes
Whether to print types as written or canonically.
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3195
unsigned IncludeTagDefinition
When true, include the body of a tag definition.
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3717
Expr * getAddrSpaceExpr() const
Definition: Type.h:3166
Provides definitions for the various language-specific address spaces.
llvm::StringRef getParameterABISpelling(ParameterABI kind)
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
qual_range quals() const
Definition: Type.h:5594
static SplitQualType splitAccordingToPolicy(QualType QT, const PrintingPolicy &Policy)
ObjCTypeParamDecl * getDecl() const
Definition: Type.h:5663
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3093
bool isValid() const
QualType getElementType() const
Definition: Type.h:2567
unsigned SuppressTagKeyword
Whether type printing should skip printing the tag keyword.
IdentifierInfo * getIdentifier() const
Definition: Type.cpp:3390
Defines the clang::LangOptions interface.
StringRef getKindName() const
Definition: Decl.h:3394
int Id
Definition: ASTDiff.cpp:190
Declaration of a template type parameter.
unsigned getIndex() const
Definition: Type.h:4691
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
unsigned getLine() const
Return the presumed line number of this location.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:558
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool appendSpaceIfNonEmpty=false) const
bool isObjCClassType() const
Definition: Type.h:6657
DeclContext * getDeclContext()
Definition: DeclBase.h:438
QualType getBaseType() const
Definition: Type.h:4439
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
Definition: Type.h:5394
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:293
Represents the type decltype(expr) (C++11).
Definition: Type.h:4370
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the &#39;<&#39; and &#39;>&#39; enclosing the template arguments.
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:593
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
bool isFunctionOrMethod() const
Definition: DeclBase.h:1836
A unary type transform, which is a type constructed from another.
Definition: Type.h:4413
Qualifiers Quals
The local qualifiers.
Definition: Type.h:598
bool isSpecifierType() const
Returns true if this type can be represented by some set of type specifiers.
Definition: Type.cpp:2593
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1784
Represents an unpacked "presumed" location which can be presented to the user.
Represents a GCC generic vector type.
Definition: Type.h:3235
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2912
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2797
unsigned SuppressSpecifiers
Whether we should suppress printing of the actual specifiers for the given type or declaration...
Definition: PrettyPrinter.h:92
UTTKind getUTTKind() const
Definition: Type.h:4441
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
Expr * getUnderlyingExpr() const
Definition: Type.h:4309
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition: Type.h:4102
bool hasQualifiers() const
Return true if the set contains any qualifiers.
Definition: Type.h:420
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:6264
RecordDecl * getDecl() const
Definition: Type.h:4505
const char * getFilename() const
Return the presumed filename of this location.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
is AltiVec &#39;vector Pixel&#39;
Definition: Type.h:3245
QualType getCanonicalType() const
Definition: Type.h:6295
not a target-specific vector type
Definition: Type.h:3239
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:4167
ElaboratedTypeKeyword getKeyword() const
Definition: Type.h:5246
unsigned getColumn() const
Return the presumed column number of this location.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5908
Sugar for parentheses used when specifying types.
Definition: Type.h:2584
QualType getAdjustedType() const
Definition: Type.h:2679
QualType getReturnType() const
Definition: Type.h:3680
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4521
Represents typeof(type), a GCC extension.
Definition: Type.h:4343
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5894
unsigned SuppressScope
Suppresses printing of scope specifiers.
ParameterABI getABI() const
Return the ABI treatment of this parameter.
Definition: Type.h:3461
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3219
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:377
CallingConv getCC() const
Definition: Type.h:3592
QualType getElementType() const
Definition: Type.h:3270
Represents a vector type where either the type or size is dependent.
Definition: Type.h:3312
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1403
Qualifiers getMethodQuals() const
Definition: Type.h:4104
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4802
QualType getEquivalentType() const
Definition: Type.h:4576
QualType getInnerType() const
Definition: Type.h:2597
is AltiVec &#39;vector bool ...&#39;
Definition: Type.h:3248
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5322
is AltiVec vector
Definition: Type.h:3242
AutoTypeKeyword getKeyword() const
Definition: Type.h:4920
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2916
TypeClass getTypeClass() const
Definition: Type.h:1876
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:5461
EnumDecl * getDecl() const
Definition: Type.h:4528
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1409
ParameterABI
Kinds of parameter ABI.
Definition: Specifiers.h:338
std::string getAsString() const
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2699
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:5133
QualType getPointeeType() const
Definition: Type.h:3167
Represents a pack expansion of types.
Definition: Type.h:5511
Defines various enumerations that describe declaration and type specifiers.
StringRef getName() const
Return the actual identifier string.
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3071
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2662
Dataflow Directional Tag Classes.
ExtInfo getExtInfo() const
Definition: Type.h:3691
NestedNameSpecifier * getQualifier() const
Definition: Type.h:5446
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
VectorKind getVectorKind() const
Definition: Type.h:3280
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2833
QualType getModifiedType() const
Definition: Type.h:4575
Pointer to a block type.
Definition: Type.h:2716
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
Complex values, per C99 6.2.5p11.
Definition: Type.h:2554
unsigned getIndexTypeCVRQualifiers() const
Definition: Type.h:2920
bool empty() const
Definition: Type.h:421
const llvm::APInt & getSize() const
Definition: Type.h:2958
Kind getAttrKind() const
Definition: Type.h:4571
bool isFunctionType() const
Definition: Type.h:6500
bool isObjCQualifiedIdType() const
Definition: Type.h:6639
ExtVectorType - Extended vector type.
Definition: Type.h:3354
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2750
bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const
QualType getUnderlyingType() const
Definition: Type.h:4358
SourceManager & getSourceManager()
Definition: ASTContext.h:679
A template argument list.
Definition: DeclTemplate.h:239
VectorType::VectorKind getVectorKind() const
Definition: Type.h:3328
TypedefNameDecl * getDecl() const
Definition: Type.h:4256
unsigned getDepth() const
Definition: Type.h:4690
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4550
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
QualType getParamType(unsigned i) const
Definition: Type.h:3966
Represents a type parameter type in Objective C.
Definition: Type.h:5620
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
Defines the clang::SourceLocation class and associated facilities.
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3429
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5420
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:5075
Represents a C array with an unspecified size.
Definition: Type.h:2995
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6283
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Definition: Type.h:5325
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4749
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2465
static QualType skipTopLevelReferences(QualType T)
bool qual_empty() const
Definition: Type.h:5598
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:250
unsigned getNumElements() const
Definition: Type.h:3271
bool isReadOnly() const
Definition: Type.h:6192
Microsoft __declspec(nothrow) extension.
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:3153
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4996
This represents a decl that may have a name.
Definition: Decl.h:223
bool isTranslationUnit() const
Definition: DeclBase.h:1859
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3039
No keyword precedes the qualified type name.
Definition: Type.h:5227
QualType getElementType() const
Definition: Type.h:3326
ConceptDecl * getTypeConstraintConcept() const
Definition: Type.h:4908
llvm::Optional< NullabilityKind > getImmediateNullability() const
Definition: Type.cpp:3958
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2935
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3533
SourceLocation getLocation() const
Definition: DeclBase.h:429
QualType getPointeeType() const
Definition: Type.h:2853
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6238
This parameter (which must have pointer type) is a Swift indirect result parameter.
const IdentifierInfo * getIdentifier() const
Definition: Type.h:5447