clang  3.7.0
TypePrinter.cpp
Go to the documentation of this file.
1 //===--- TypePrinter.cpp - Pretty-Print Clang Types -----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code to print types from Clang's type system.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Decl.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/Type.h"
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/Support/SaveAndRestore.h"
26 #include "llvm/Support/raw_ostream.h"
27 using namespace clang;
28 
29 namespace {
30  /// \brief RAII object that enables printing of the ARC __strong lifetime
31  /// qualifier.
32  class IncludeStrongLifetimeRAII {
33  PrintingPolicy &Policy;
34  bool Old;
35 
36  public:
37  explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy)
38  : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
39  if (!Policy.SuppressLifetimeQualifiers)
40  Policy.SuppressStrongLifetime = false;
41  }
42 
43  ~IncludeStrongLifetimeRAII() {
44  Policy.SuppressStrongLifetime = Old;
45  }
46  };
47 
48  class ParamPolicyRAII {
49  PrintingPolicy &Policy;
50  bool Old;
51 
52  public:
53  explicit ParamPolicyRAII(PrintingPolicy &Policy)
54  : Policy(Policy), Old(Policy.SuppressSpecifiers) {
55  Policy.SuppressSpecifiers = false;
56  }
57 
58  ~ParamPolicyRAII() {
59  Policy.SuppressSpecifiers = Old;
60  }
61  };
62 
63  class ElaboratedTypePolicyRAII {
64  PrintingPolicy &Policy;
65  bool SuppressTagKeyword;
66  bool SuppressScope;
67 
68  public:
69  explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) {
70  SuppressTagKeyword = Policy.SuppressTagKeyword;
71  SuppressScope = Policy.SuppressScope;
72  Policy.SuppressTagKeyword = true;
73  Policy.SuppressScope = true;
74  }
75 
76  ~ElaboratedTypePolicyRAII() {
77  Policy.SuppressTagKeyword = SuppressTagKeyword;
78  Policy.SuppressScope = SuppressScope;
79  }
80  };
81 
82  class TypePrinter {
83  PrintingPolicy Policy;
84  bool HasEmptyPlaceHolder;
85  bool InsideCCAttribute;
86 
87  public:
88  explicit TypePrinter(const PrintingPolicy &Policy)
89  : Policy(Policy), HasEmptyPlaceHolder(false), InsideCCAttribute(false) { }
90 
91  void print(const Type *ty, Qualifiers qs, raw_ostream &OS,
92  StringRef PlaceHolder);
93  void print(QualType T, raw_ostream &OS, StringRef PlaceHolder);
94 
95  static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier);
96  void spaceBeforePlaceHolder(raw_ostream &OS);
97  void printTypeSpec(const NamedDecl *D, raw_ostream &OS);
98 
99  void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS);
100  void printBefore(QualType T, raw_ostream &OS);
101  void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS);
102  void printAfter(QualType T, raw_ostream &OS);
103  void AppendScope(DeclContext *DC, raw_ostream &OS);
104  void printTag(TagDecl *T, raw_ostream &OS);
105 #define ABSTRACT_TYPE(CLASS, PARENT)
106 #define TYPE(CLASS, PARENT) \
107  void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \
108  void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS);
109 #include "clang/AST/TypeNodes.def"
110  };
111 }
112 
113 static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals, bool C99) {
114  bool appendSpace = false;
115  if (TypeQuals & Qualifiers::Const) {
116  OS << "const";
117  appendSpace = true;
118  }
119  if (TypeQuals & Qualifiers::Volatile) {
120  if (appendSpace) OS << ' ';
121  OS << "volatile";
122  appendSpace = true;
123  }
124  if (TypeQuals & Qualifiers::Restrict) {
125  if (appendSpace) OS << ' ';
126  if (C99) {
127  OS << "restrict";
128  } else {
129  OS << "__restrict";
130  }
131  }
132 }
133 
134 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) {
135  if (!HasEmptyPlaceHolder)
136  OS << ' ';
137 }
138 
139 void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) {
140  SplitQualType split = t.split();
141  print(split.Ty, split.Quals, OS, PlaceHolder);
142 }
143 
144 void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
145  StringRef PlaceHolder) {
146  if (!T) {
147  OS << "NULL TYPE";
148  return;
149  }
150 
151  SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty());
152 
153  printBefore(T, Quals, OS);
154  OS << PlaceHolder;
155  printAfter(T, Quals, OS);
156 }
157 
158 bool TypePrinter::canPrefixQualifiers(const Type *T,
159  bool &NeedARCStrongQualifier) {
160  // CanPrefixQualifiers - We prefer to print type qualifiers before the type,
161  // so that we get "const int" instead of "int const", but we can't do this if
162  // the type is complex. For example if the type is "int*", we *must* print
163  // "int * const", printing "const int *" is different. Only do this when the
164  // type expands to a simple string.
165  bool CanPrefixQualifiers = false;
166  NeedARCStrongQualifier = false;
167  Type::TypeClass TC = T->getTypeClass();
168  if (const AutoType *AT = dyn_cast<AutoType>(T))
169  TC = AT->desugar()->getTypeClass();
170  if (const SubstTemplateTypeParmType *Subst
171  = dyn_cast<SubstTemplateTypeParmType>(T))
172  TC = Subst->getReplacementType()->getTypeClass();
173 
174  switch (TC) {
175  case Type::Auto:
176  case Type::Builtin:
177  case Type::Complex:
178  case Type::UnresolvedUsing:
179  case Type::Typedef:
180  case Type::TypeOfExpr:
181  case Type::TypeOf:
182  case Type::Decltype:
183  case Type::UnaryTransform:
184  case Type::Record:
185  case Type::Enum:
186  case Type::Elaborated:
187  case Type::TemplateTypeParm:
188  case Type::SubstTemplateTypeParmPack:
189  case Type::TemplateSpecialization:
190  case Type::InjectedClassName:
191  case Type::DependentName:
192  case Type::DependentTemplateSpecialization:
193  case Type::ObjCObject:
194  case Type::ObjCInterface:
195  case Type::Atomic:
196  CanPrefixQualifiers = true;
197  break;
198 
199  case Type::ObjCObjectPointer:
200  CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
202  break;
203 
204  case Type::ConstantArray:
205  case Type::IncompleteArray:
206  case Type::VariableArray:
207  case Type::DependentSizedArray:
208  NeedARCStrongQualifier = true;
209  // Fall through
210 
211  case Type::Adjusted:
212  case Type::Decayed:
213  case Type::Pointer:
214  case Type::BlockPointer:
215  case Type::LValueReference:
216  case Type::RValueReference:
217  case Type::MemberPointer:
218  case Type::DependentSizedExtVector:
219  case Type::Vector:
220  case Type::ExtVector:
221  case Type::FunctionProto:
222  case Type::FunctionNoProto:
223  case Type::Paren:
224  case Type::Attributed:
225  case Type::PackExpansion:
226  case Type::SubstTemplateTypeParm:
227  CanPrefixQualifiers = false;
228  break;
229  }
230 
231  return CanPrefixQualifiers;
232 }
233 
234 void TypePrinter::printBefore(QualType T, raw_ostream &OS) {
235  SplitQualType Split = T.split();
236 
237  // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2
238  // at this level.
239  Qualifiers Quals = Split.Quals;
240  if (const SubstTemplateTypeParmType *Subst =
241  dyn_cast<SubstTemplateTypeParmType>(Split.Ty))
242  Quals -= QualType(Subst, 0).getQualifiers();
243 
244  printBefore(Split.Ty, Quals, OS);
245 }
246 
247 /// \brief Prints the part of the type string before an identifier, e.g. for
248 /// "int foo[10]" it prints "int ".
249 void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) {
250  if (Policy.SuppressSpecifiers && T->isSpecifierType())
251  return;
252 
253  SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder);
254 
255  // Print qualifiers as appropriate.
256 
257  bool CanPrefixQualifiers = false;
258  bool NeedARCStrongQualifier = false;
259  CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier);
260 
261  if (CanPrefixQualifiers && !Quals.empty()) {
262  if (NeedARCStrongQualifier) {
263  IncludeStrongLifetimeRAII Strong(Policy);
264  Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
265  } else {
266  Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
267  }
268  }
269 
270  bool hasAfterQuals = false;
271  if (!CanPrefixQualifiers && !Quals.empty()) {
272  hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy);
273  if (hasAfterQuals)
274  HasEmptyPlaceHolder = false;
275  }
276 
277  switch (T->getTypeClass()) {
278 #define ABSTRACT_TYPE(CLASS, PARENT)
279 #define TYPE(CLASS, PARENT) case Type::CLASS: \
280  print##CLASS##Before(cast<CLASS##Type>(T), OS); \
281  break;
282 #include "clang/AST/TypeNodes.def"
283  }
284 
285  if (hasAfterQuals) {
286  if (NeedARCStrongQualifier) {
287  IncludeStrongLifetimeRAII Strong(Policy);
288  Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
289  } else {
290  Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
291  }
292  }
293 }
294 
295 void TypePrinter::printAfter(QualType t, raw_ostream &OS) {
296  SplitQualType split = t.split();
297  printAfter(split.Ty, split.Quals, OS);
298 }
299 
300 /// \brief Prints the part of the type string after an identifier, e.g. for
301 /// "int foo[10]" it prints "[10]".
302 void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) {
303  switch (T->getTypeClass()) {
304 #define ABSTRACT_TYPE(CLASS, PARENT)
305 #define TYPE(CLASS, PARENT) case Type::CLASS: \
306  print##CLASS##After(cast<CLASS##Type>(T), OS); \
307  break;
308 #include "clang/AST/TypeNodes.def"
309  }
310 }
311 
312 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) {
313  OS << T->getName(Policy);
314  spaceBeforePlaceHolder(OS);
315 }
316 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) { }
317 
318 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) {
319  OS << "_Complex ";
320  printBefore(T->getElementType(), OS);
321 }
322 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) {
323  printAfter(T->getElementType(), OS);
324 }
325 
326 void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) {
327  IncludeStrongLifetimeRAII Strong(Policy);
328  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
329  printBefore(T->getPointeeType(), OS);
330  // Handle things like 'int (*A)[4];' correctly.
331  // FIXME: this should include vectors, but vectors use attributes I guess.
332  if (isa<ArrayType>(T->getPointeeType()))
333  OS << '(';
334  OS << '*';
335 }
336 void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) {
337  IncludeStrongLifetimeRAII Strong(Policy);
338  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
339  // Handle things like 'int (*A)[4];' correctly.
340  // FIXME: this should include vectors, but vectors use attributes I guess.
341  if (isa<ArrayType>(T->getPointeeType()))
342  OS << ')';
343  printAfter(T->getPointeeType(), OS);
344 }
345 
346 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T,
347  raw_ostream &OS) {
348  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
349  printBefore(T->getPointeeType(), OS);
350  OS << '^';
351 }
352 void TypePrinter::printBlockPointerAfter(const BlockPointerType *T,
353  raw_ostream &OS) {
354  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
355  printAfter(T->getPointeeType(), OS);
356 }
357 
358 void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T,
359  raw_ostream &OS) {
360  IncludeStrongLifetimeRAII Strong(Policy);
361  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
362  printBefore(T->getPointeeTypeAsWritten(), OS);
363  // Handle things like 'int (&A)[4];' correctly.
364  // FIXME: this should include vectors, but vectors use attributes I guess.
365  if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
366  OS << '(';
367  OS << '&';
368 }
369 void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T,
370  raw_ostream &OS) {
371  IncludeStrongLifetimeRAII Strong(Policy);
372  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
373  // Handle things like 'int (&A)[4];' correctly.
374  // FIXME: this should include vectors, but vectors use attributes I guess.
375  if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
376  OS << ')';
377  printAfter(T->getPointeeTypeAsWritten(), OS);
378 }
379 
380 void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T,
381  raw_ostream &OS) {
382  IncludeStrongLifetimeRAII Strong(Policy);
383  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
384  printBefore(T->getPointeeTypeAsWritten(), OS);
385  // Handle things like 'int (&&A)[4];' correctly.
386  // FIXME: this should include vectors, but vectors use attributes I guess.
387  if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
388  OS << '(';
389  OS << "&&";
390 }
391 void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T,
392  raw_ostream &OS) {
393  IncludeStrongLifetimeRAII Strong(Policy);
394  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
395  // Handle things like 'int (&&A)[4];' correctly.
396  // FIXME: this should include vectors, but vectors use attributes I guess.
397  if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
398  OS << ')';
399  printAfter(T->getPointeeTypeAsWritten(), OS);
400 }
401 
402 void TypePrinter::printMemberPointerBefore(const MemberPointerType *T,
403  raw_ostream &OS) {
404  IncludeStrongLifetimeRAII Strong(Policy);
405  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
406  printBefore(T->getPointeeType(), OS);
407  // Handle things like 'int (Cls::*A)[4];' correctly.
408  // FIXME: this should include vectors, but vectors use attributes I guess.
409  if (isa<ArrayType>(T->getPointeeType()))
410  OS << '(';
411 
412  PrintingPolicy InnerPolicy(Policy);
413  InnerPolicy.SuppressTag = false;
414  TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef());
415 
416  OS << "::*";
417 }
418 void TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
419  raw_ostream &OS) {
420  IncludeStrongLifetimeRAII Strong(Policy);
421  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
422  // Handle things like 'int (Cls::*A)[4];' correctly.
423  // FIXME: this should include vectors, but vectors use attributes I guess.
424  if (isa<ArrayType>(T->getPointeeType()))
425  OS << ')';
426  printAfter(T->getPointeeType(), OS);
427 }
428 
429 void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T,
430  raw_ostream &OS) {
431  IncludeStrongLifetimeRAII Strong(Policy);
432  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
433  printBefore(T->getElementType(), OS);
434 }
435 void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
436  raw_ostream &OS) {
437  OS << '[';
439  AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.LangOpts.C99);
440  OS << ' ';
441  }
442 
444  OS << "static ";
445 
446  OS << T->getSize().getZExtValue() << ']';
447  printAfter(T->getElementType(), OS);
448 }
449 
450 void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T,
451  raw_ostream &OS) {
452  IncludeStrongLifetimeRAII Strong(Policy);
453  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
454  printBefore(T->getElementType(), OS);
455 }
456 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
457  raw_ostream &OS) {
458  OS << "[]";
459  printAfter(T->getElementType(), OS);
460 }
461 
462 void TypePrinter::printVariableArrayBefore(const VariableArrayType *T,
463  raw_ostream &OS) {
464  IncludeStrongLifetimeRAII Strong(Policy);
465  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
466  printBefore(T->getElementType(), OS);
467 }
468 void TypePrinter::printVariableArrayAfter(const VariableArrayType *T,
469  raw_ostream &OS) {
470  OS << '[';
472  AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.LangOpts.C99);
473  OS << ' ';
474  }
475 
477  OS << "static ";
478  else if (T->getSizeModifier() == VariableArrayType::Star)
479  OS << '*';
480 
481  if (T->getSizeExpr())
482  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
483  OS << ']';
484 
485  printAfter(T->getElementType(), OS);
486 }
487 
488 void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) {
489  // Print the adjusted representation, otherwise the adjustment will be
490  // invisible.
491  printBefore(T->getAdjustedType(), OS);
492 }
493 void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) {
494  printAfter(T->getAdjustedType(), OS);
495 }
496 
497 void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) {
498  // Print as though it's a pointer.
499  printAdjustedBefore(T, OS);
500 }
501 void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) {
502  printAdjustedAfter(T, OS);
503 }
504 
505 void TypePrinter::printDependentSizedArrayBefore(
506  const DependentSizedArrayType *T,
507  raw_ostream &OS) {
508  IncludeStrongLifetimeRAII Strong(Policy);
509  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
510  printBefore(T->getElementType(), OS);
511 }
512 void TypePrinter::printDependentSizedArrayAfter(
513  const DependentSizedArrayType *T,
514  raw_ostream &OS) {
515  OS << '[';
516  if (T->getSizeExpr())
517  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
518  OS << ']';
519  printAfter(T->getElementType(), OS);
520 }
521 
522 void TypePrinter::printDependentSizedExtVectorBefore(
523  const DependentSizedExtVectorType *T,
524  raw_ostream &OS) {
525  printBefore(T->getElementType(), OS);
526 }
527 void TypePrinter::printDependentSizedExtVectorAfter(
528  const DependentSizedExtVectorType *T,
529  raw_ostream &OS) {
530  OS << " __attribute__((ext_vector_type(";
531  if (T->getSizeExpr())
532  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
533  OS << ")))";
534  printAfter(T->getElementType(), OS);
535 }
536 
537 void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) {
538  switch (T->getVectorKind()) {
540  OS << "__vector __pixel ";
541  break;
543  OS << "__vector __bool ";
544  printBefore(T->getElementType(), OS);
545  break;
547  OS << "__vector ";
548  printBefore(T->getElementType(), OS);
549  break;
551  OS << "__attribute__((neon_vector_type("
552  << T->getNumElements() << "))) ";
553  printBefore(T->getElementType(), OS);
554  break;
556  OS << "__attribute__((neon_polyvector_type(" <<
557  T->getNumElements() << "))) ";
558  printBefore(T->getElementType(), OS);
559  break;
561  // FIXME: We prefer to print the size directly here, but have no way
562  // to get the size of the type.
563  OS << "__attribute__((__vector_size__("
564  << T->getNumElements()
565  << " * sizeof(";
566  print(T->getElementType(), OS, StringRef());
567  OS << ")))) ";
568  printBefore(T->getElementType(), OS);
569  break;
570  }
571  }
572 }
573 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) {
574  printAfter(T->getElementType(), OS);
575 }
576 
577 void TypePrinter::printExtVectorBefore(const ExtVectorType *T,
578  raw_ostream &OS) {
579  printBefore(T->getElementType(), OS);
580 }
581 void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) {
582  printAfter(T->getElementType(), OS);
583  OS << " __attribute__((ext_vector_type(";
584  OS << T->getNumElements();
585  OS << ")))";
586 }
587 
588 void
590  const PrintingPolicy &Policy)
591  const {
592 
593  if (hasDynamicExceptionSpec()) {
594  OS << " throw(";
596  OS << "...";
597  else
598  for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) {
599  if (I)
600  OS << ", ";
601 
602  OS << getExceptionType(I).stream(Policy);
603  }
604  OS << ')';
606  OS << " noexcept";
608  OS << '(';
609  if (getNoexceptExpr())
610  getNoexceptExpr()->printPretty(OS, nullptr, Policy);
611  OS << ')';
612  }
613  }
614 }
615 
616 void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T,
617  raw_ostream &OS) {
618  if (T->hasTrailingReturn()) {
619  OS << "auto ";
620  if (!HasEmptyPlaceHolder)
621  OS << '(';
622  } else {
623  // If needed for precedence reasons, wrap the inner part in grouping parens.
624  SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
625  printBefore(T->getReturnType(), OS);
626  if (!PrevPHIsEmpty.get())
627  OS << '(';
628  }
629 }
630 
631 void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
632  raw_ostream &OS) {
633  // If needed for precedence reasons, wrap the inner part in grouping parens.
634  if (!HasEmptyPlaceHolder)
635  OS << ')';
636  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
637 
638  OS << '(';
639  {
640  ParamPolicyRAII ParamPolicy(Policy);
641  for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) {
642  if (i) OS << ", ";
643  print(T->getParamType(i), OS, StringRef());
644  }
645  }
646 
647  if (T->isVariadic()) {
648  if (T->getNumParams())
649  OS << ", ";
650  OS << "...";
651  } else if (T->getNumParams() == 0 && !Policy.LangOpts.CPlusPlus) {
652  // Do not emit int() if we have a proto, emit 'int(void)'.
653  OS << "void";
654  }
655 
656  OS << ')';
657 
658  FunctionType::ExtInfo Info = T->getExtInfo();
659 
660  if (!InsideCCAttribute) {
661  switch (Info.getCC()) {
662  case CC_C:
663  // The C calling convention is the default on the vast majority of platforms
664  // we support. If the user wrote it explicitly, it will usually be printed
665  // while traversing the AttributedType. If the type has been desugared, let
666  // the canonical spelling be the implicit calling convention.
667  // FIXME: It would be better to be explicit in certain contexts, such as a
668  // cdecl function typedef used to declare a member function with the
669  // Microsoft C++ ABI.
670  break;
671  case CC_X86StdCall:
672  OS << " __attribute__((stdcall))";
673  break;
674  case CC_X86FastCall:
675  OS << " __attribute__((fastcall))";
676  break;
677  case CC_X86ThisCall:
678  OS << " __attribute__((thiscall))";
679  break;
680  case CC_X86VectorCall:
681  OS << " __attribute__((vectorcall))";
682  break;
683  case CC_X86Pascal:
684  OS << " __attribute__((pascal))";
685  break;
686  case CC_AAPCS:
687  OS << " __attribute__((pcs(\"aapcs\")))";
688  break;
689  case CC_AAPCS_VFP:
690  OS << " __attribute__((pcs(\"aapcs-vfp\")))";
691  break;
692  case CC_IntelOclBicc:
693  OS << " __attribute__((intel_ocl_bicc))";
694  break;
695  case CC_X86_64Win64:
696  OS << " __attribute__((ms_abi))";
697  break;
698  case CC_X86_64SysV:
699  OS << " __attribute__((sysv_abi))";
700  break;
701  case CC_SpirFunction:
702  case CC_SpirKernel:
703  // Do nothing. These CCs are not available as attributes.
704  break;
705  }
706  }
707 
708  if (Info.getNoReturn())
709  OS << " __attribute__((noreturn))";
710  if (Info.getRegParm())
711  OS << " __attribute__((regparm ("
712  << Info.getRegParm() << ")))";
713 
714  if (unsigned quals = T->getTypeQuals()) {
715  OS << ' ';
716  AppendTypeQualList(OS, quals, Policy.LangOpts.C99);
717  }
718 
719  switch (T->getRefQualifier()) {
720  case RQ_None:
721  break;
722 
723  case RQ_LValue:
724  OS << " &";
725  break;
726 
727  case RQ_RValue:
728  OS << " &&";
729  break;
730  }
731  T->printExceptionSpecification(OS, Policy);
732 
733  if (T->hasTrailingReturn()) {
734  OS << " -> ";
735  print(T->getReturnType(), OS, StringRef());
736  } else
737  printAfter(T->getReturnType(), OS);
738 }
739 
740 void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T,
741  raw_ostream &OS) {
742  // If needed for precedence reasons, wrap the inner part in grouping parens.
743  SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
744  printBefore(T->getReturnType(), OS);
745  if (!PrevPHIsEmpty.get())
746  OS << '(';
747 }
748 void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T,
749  raw_ostream &OS) {
750  // If needed for precedence reasons, wrap the inner part in grouping parens.
751  if (!HasEmptyPlaceHolder)
752  OS << ')';
753  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
754 
755  OS << "()";
756  if (T->getNoReturnAttr())
757  OS << " __attribute__((noreturn))";
758  printAfter(T->getReturnType(), OS);
759 }
760 
761 void TypePrinter::printTypeSpec(const NamedDecl *D, raw_ostream &OS) {
762  IdentifierInfo *II = D->getIdentifier();
763  OS << II->getName();
764  spaceBeforePlaceHolder(OS);
765 }
766 
767 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
768  raw_ostream &OS) {
769  printTypeSpec(T->getDecl(), OS);
770 }
771 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
772  raw_ostream &OS) { }
773 
774 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
775  printTypeSpec(T->getDecl(), OS);
776 }
777 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) { }
778 
779 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
780  raw_ostream &OS) {
781  OS << "typeof ";
782  if (T->getUnderlyingExpr())
783  T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
784  spaceBeforePlaceHolder(OS);
785 }
786 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
787  raw_ostream &OS) { }
788 
789 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
790  OS << "typeof(";
791  print(T->getUnderlyingType(), OS, StringRef());
792  OS << ')';
793  spaceBeforePlaceHolder(OS);
794 }
795 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) { }
796 
797 void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
798  OS << "decltype(";
799  if (T->getUnderlyingExpr())
800  T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
801  OS << ')';
802  spaceBeforePlaceHolder(OS);
803 }
804 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) { }
805 
806 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
807  raw_ostream &OS) {
808  IncludeStrongLifetimeRAII Strong(Policy);
809 
810  switch (T->getUTTKind()) {
812  OS << "__underlying_type(";
813  print(T->getBaseType(), OS, StringRef());
814  OS << ')';
815  spaceBeforePlaceHolder(OS);
816  return;
817  }
818 
819  printBefore(T->getBaseType(), OS);
820 }
821 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
822  raw_ostream &OS) {
823  IncludeStrongLifetimeRAII Strong(Policy);
824 
825  switch (T->getUTTKind()) {
827  return;
828  }
829 
830  printAfter(T->getBaseType(), OS);
831 }
832 
833 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
834  // If the type has been deduced, do not print 'auto'.
835  if (!T->getDeducedType().isNull()) {
836  printBefore(T->getDeducedType(), OS);
837  } else {
838  OS << (T->isDecltypeAuto() ? "decltype(auto)" : "auto");
839  spaceBeforePlaceHolder(OS);
840  }
841 }
842 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
843  // If the type has been deduced, do not print 'auto'.
844  if (!T->getDeducedType().isNull())
845  printAfter(T->getDeducedType(), OS);
846 }
847 
848 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) {
849  IncludeStrongLifetimeRAII Strong(Policy);
850 
851  OS << "_Atomic(";
852  print(T->getValueType(), OS, StringRef());
853  OS << ')';
854  spaceBeforePlaceHolder(OS);
855 }
856 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) { }
857 
858 /// Appends the given scope to the end of a string.
859 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) {
860  if (DC->isTranslationUnit()) return;
861  if (DC->isFunctionOrMethod()) return;
862  AppendScope(DC->getParent(), OS);
863 
864  if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DC)) {
865  if (Policy.SuppressUnwrittenScope &&
866  (NS->isAnonymousNamespace() || NS->isInline()))
867  return;
868  if (NS->getIdentifier())
869  OS << NS->getName() << "::";
870  else
871  OS << "(anonymous namespace)::";
872  } else if (ClassTemplateSpecializationDecl *Spec
873  = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
874  IncludeStrongLifetimeRAII Strong(Policy);
875  OS << Spec->getIdentifier()->getName();
876  const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
878  TemplateArgs.data(),
879  TemplateArgs.size(),
880  Policy);
881  OS << "::";
882  } else if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) {
883  if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
884  OS << Typedef->getIdentifier()->getName() << "::";
885  else if (Tag->getIdentifier())
886  OS << Tag->getIdentifier()->getName() << "::";
887  else
888  return;
889  }
890 }
891 
892 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
893  if (Policy.SuppressTag)
894  return;
895 
896  bool HasKindDecoration = false;
897 
898  // bool SuppressTagKeyword
899  // = Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword;
900 
901  // We don't print tags unless this is an elaborated type.
902  // In C, we just assume every RecordType is an elaborated type.
903  if (!(Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword ||
905  HasKindDecoration = true;
906  OS << D->getKindName();
907  OS << ' ';
908  }
909 
910  // Compute the full nested-name-specifier for this type.
911  // In C, this will always be empty except when the type
912  // being printed is anonymous within other Record.
913  if (!Policy.SuppressScope)
914  AppendScope(D->getDeclContext(), OS);
915 
916  if (const IdentifierInfo *II = D->getIdentifier())
917  OS << II->getName();
918  else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
919  assert(Typedef->getIdentifier() && "Typedef without identifier?");
920  OS << Typedef->getIdentifier()->getName();
921  } else {
922  // Make an unambiguous representation for anonymous types, e.g.
923  // (anonymous enum at /usr/include/string.h:120:9)
924 
925  if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) {
926  OS << "(lambda";
927  HasKindDecoration = true;
928  } else {
929  OS << "(anonymous";
930  }
931 
932  if (Policy.AnonymousTagLocations) {
933  // Suppress the redundant tag keyword if we just printed one.
934  // We don't have to worry about ElaboratedTypes here because you can't
935  // refer to an anonymous type with one.
936  if (!HasKindDecoration)
937  OS << " " << D->getKindName();
938 
940  D->getLocation());
941  if (PLoc.isValid()) {
942  OS << " at " << PLoc.getFilename()
943  << ':' << PLoc.getLine()
944  << ':' << PLoc.getColumn();
945  }
946  }
947 
948  OS << ')';
949  }
950 
951  // If this is a class template specialization, print the template
952  // arguments.
954  = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
955  const TemplateArgument *Args;
956  unsigned NumArgs;
957  if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
958  const TemplateSpecializationType *TST =
959  cast<TemplateSpecializationType>(TAW->getType());
960  Args = TST->getArgs();
961  NumArgs = TST->getNumArgs();
962  } else {
963  const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
964  Args = TemplateArgs.data();
965  NumArgs = TemplateArgs.size();
966  }
967  IncludeStrongLifetimeRAII Strong(Policy);
969  Args, NumArgs,
970  Policy);
971  }
972 
973  spaceBeforePlaceHolder(OS);
974 }
975 
976 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
977  printTag(T->getDecl(), OS);
978 }
979 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) { }
980 
981 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
982  printTag(T->getDecl(), OS);
983 }
984 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) { }
985 
986 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
987  raw_ostream &OS) {
988  if (IdentifierInfo *Id = T->getIdentifier())
989  OS << Id->getName();
990  else
991  OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
992  spaceBeforePlaceHolder(OS);
993 }
994 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
995  raw_ostream &OS) { }
996 
997 void TypePrinter::printSubstTemplateTypeParmBefore(
998  const SubstTemplateTypeParmType *T,
999  raw_ostream &OS) {
1000  IncludeStrongLifetimeRAII Strong(Policy);
1001  printBefore(T->getReplacementType(), OS);
1002 }
1003 void TypePrinter::printSubstTemplateTypeParmAfter(
1004  const SubstTemplateTypeParmType *T,
1005  raw_ostream &OS) {
1006  IncludeStrongLifetimeRAII Strong(Policy);
1007  printAfter(T->getReplacementType(), OS);
1008 }
1009 
1010 void TypePrinter::printSubstTemplateTypeParmPackBefore(
1012  raw_ostream &OS) {
1013  IncludeStrongLifetimeRAII Strong(Policy);
1014  printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1015 }
1016 void TypePrinter::printSubstTemplateTypeParmPackAfter(
1018  raw_ostream &OS) {
1019  IncludeStrongLifetimeRAII Strong(Policy);
1020  printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1021 }
1022 
1023 void TypePrinter::printTemplateSpecializationBefore(
1024  const TemplateSpecializationType *T,
1025  raw_ostream &OS) {
1026  IncludeStrongLifetimeRAII Strong(Policy);
1027  T->getTemplateName().print(OS, Policy);
1028 
1030  T->getArgs(),
1031  T->getNumArgs(),
1032  Policy);
1033  spaceBeforePlaceHolder(OS);
1034 }
1035 void TypePrinter::printTemplateSpecializationAfter(
1036  const TemplateSpecializationType *T,
1037  raw_ostream &OS) { }
1038 
1039 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
1040  raw_ostream &OS) {
1041  printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1042 }
1043 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
1044  raw_ostream &OS) { }
1045 
1046 void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
1047  raw_ostream &OS) {
1048  if (Policy.SuppressTag && isa<TagType>(T->getNamedType()))
1049  return;
1051  if (T->getKeyword() != ETK_None)
1052  OS << " ";
1053  NestedNameSpecifier* Qualifier = T->getQualifier();
1054  if (Qualifier)
1055  Qualifier->print(OS, Policy);
1056 
1057  ElaboratedTypePolicyRAII PolicyRAII(Policy);
1058  printBefore(T->getNamedType(), OS);
1059 }
1060 void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
1061  raw_ostream &OS) {
1062  ElaboratedTypePolicyRAII PolicyRAII(Policy);
1063  printAfter(T->getNamedType(), OS);
1064 }
1065 
1066 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
1067  if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1068  printBefore(T->getInnerType(), OS);
1069  OS << '(';
1070  } else
1071  printBefore(T->getInnerType(), OS);
1072 }
1073 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
1074  if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1075  OS << ')';
1076  printAfter(T->getInnerType(), OS);
1077  } else
1078  printAfter(T->getInnerType(), OS);
1079 }
1080 
1081 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
1082  raw_ostream &OS) {
1084  if (T->getKeyword() != ETK_None)
1085  OS << " ";
1086 
1087  T->getQualifier()->print(OS, Policy);
1088 
1089  OS << T->getIdentifier()->getName();
1090  spaceBeforePlaceHolder(OS);
1091 }
1092 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
1093  raw_ostream &OS) { }
1094 
1095 void TypePrinter::printDependentTemplateSpecializationBefore(
1096  const DependentTemplateSpecializationType *T, raw_ostream &OS) {
1097  IncludeStrongLifetimeRAII Strong(Policy);
1098 
1100  if (T->getKeyword() != ETK_None)
1101  OS << " ";
1102 
1103  if (T->getQualifier())
1104  T->getQualifier()->print(OS, Policy);
1105  OS << T->getIdentifier()->getName();
1107  T->getArgs(),
1108  T->getNumArgs(),
1109  Policy);
1110  spaceBeforePlaceHolder(OS);
1111 }
1112 void TypePrinter::printDependentTemplateSpecializationAfter(
1113  const DependentTemplateSpecializationType *T, raw_ostream &OS) { }
1114 
1115 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
1116  raw_ostream &OS) {
1117  printBefore(T->getPattern(), OS);
1118 }
1119 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
1120  raw_ostream &OS) {
1121  printAfter(T->getPattern(), OS);
1122  OS << "...";
1123 }
1124 
1125 void TypePrinter::printAttributedBefore(const AttributedType *T,
1126  raw_ostream &OS) {
1127  // Prefer the macro forms of the GC and ownership qualifiers.
1130  return printBefore(T->getEquivalentType(), OS);
1131 
1133  OS << "__kindof ";
1134 
1135  printBefore(T->getModifiedType(), OS);
1136 
1137  if (T->isMSTypeSpec()) {
1138  switch (T->getAttrKind()) {
1139  default: return;
1140  case AttributedType::attr_ptr32: OS << " __ptr32"; break;
1141  case AttributedType::attr_ptr64: OS << " __ptr64"; break;
1142  case AttributedType::attr_sptr: OS << " __sptr"; break;
1143  case AttributedType::attr_uptr: OS << " __uptr"; break;
1144  }
1145  spaceBeforePlaceHolder(OS);
1146  }
1147 
1148  // Print nullability type specifiers.
1153  OS << " _Nonnull";
1154  else if (T->getAttrKind() == AttributedType::attr_nullable)
1155  OS << " _Nullable";
1157  OS << " _Null_unspecified";
1158  else
1159  llvm_unreachable("unhandled nullability");
1160  spaceBeforePlaceHolder(OS);
1161  }
1162 }
1163 
1164 void TypePrinter::printAttributedAfter(const AttributedType *T,
1165  raw_ostream &OS) {
1166  // Prefer the macro forms of the GC and ownership qualifiers.
1169  return printAfter(T->getEquivalentType(), OS);
1170 
1172  return;
1173 
1174  // TODO: not all attributes are GCC-style attributes.
1175  if (T->isMSTypeSpec())
1176  return;
1177 
1178  // Nothing to print after.
1182  return printAfter(T->getModifiedType(), OS);
1183 
1184  // If this is a calling convention attribute, don't print the implicit CC from
1185  // the modified type.
1186  SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv());
1187 
1188  printAfter(T->getModifiedType(), OS);
1189 
1190  // Print nullability type specifiers that occur after
1195  OS << " _Nonnull";
1196  else if (T->getAttrKind() == AttributedType::attr_nullable)
1197  OS << " _Nullable";
1199  OS << " _Null_unspecified";
1200  else
1201  llvm_unreachable("unhandled nullability");
1202 
1203  return;
1204  }
1205 
1206  OS << " __attribute__((";
1207  switch (T->getAttrKind()) {
1208  default: llvm_unreachable("This attribute should have been handled already");
1210  OS << "address_space(";
1211  OS << T->getEquivalentType().getAddressSpace();
1212  OS << ')';
1213  break;
1214 
1216  OS << "__vector_size__(";
1217  if (const VectorType *vector =T->getEquivalentType()->getAs<VectorType>()) {
1218  OS << vector->getNumElements();
1219  OS << " * sizeof(";
1220  print(vector->getElementType(), OS, StringRef());
1221  OS << ')';
1222  }
1223  OS << ')';
1224  break;
1225  }
1226 
1230  OS << "neon_vector_type(";
1231  else
1232  OS << "neon_polyvector_type(";
1233  const VectorType *vector = T->getEquivalentType()->getAs<VectorType>();
1234  OS << vector->getNumElements();
1235  OS << ')';
1236  break;
1237  }
1238 
1240  // FIXME: When Sema learns to form this AttributedType, avoid printing the
1241  // attribute again in printFunctionProtoAfter.
1242  OS << "regparm(";
1243  QualType t = T->getEquivalentType();
1244  while (!t->isFunctionType())
1245  t = t->getPointeeType();
1246  OS << t->getAs<FunctionType>()->getRegParmType();
1247  OS << ')';
1248  break;
1249  }
1250 
1252  OS << "objc_gc(";
1253 
1254  QualType tmp = T->getEquivalentType();
1255  while (tmp.getObjCGCAttr() == Qualifiers::GCNone) {
1256  QualType next = tmp->getPointeeType();
1257  if (next == tmp) break;
1258  tmp = next;
1259  }
1260 
1261  if (tmp.isObjCGCWeak())
1262  OS << "weak";
1263  else
1264  OS << "strong";
1265  OS << ')';
1266  break;
1267  }
1268 
1270  OS << "objc_ownership(";
1271  switch (T->getEquivalentType().getObjCLifetime()) {
1272  case Qualifiers::OCL_None: llvm_unreachable("no ownership!");
1273  case Qualifiers::OCL_ExplicitNone: OS << "none"; break;
1274  case Qualifiers::OCL_Strong: OS << "strong"; break;
1275  case Qualifiers::OCL_Weak: OS << "weak"; break;
1276  case Qualifiers::OCL_Autoreleasing: OS << "autoreleasing"; break;
1277  }
1278  OS << ')';
1279  break;
1280 
1281  // FIXME: When Sema learns to form this AttributedType, avoid printing the
1282  // attribute again in printFunctionProtoAfter.
1283  case AttributedType::attr_noreturn: OS << "noreturn"; break;
1284 
1285  case AttributedType::attr_cdecl: OS << "cdecl"; break;
1286  case AttributedType::attr_fastcall: OS << "fastcall"; break;
1287  case AttributedType::attr_stdcall: OS << "stdcall"; break;
1288  case AttributedType::attr_thiscall: OS << "thiscall"; break;
1289  case AttributedType::attr_vectorcall: OS << "vectorcall"; break;
1290  case AttributedType::attr_pascal: OS << "pascal"; break;
1291  case AttributedType::attr_ms_abi: OS << "ms_abi"; break;
1292  case AttributedType::attr_sysv_abi: OS << "sysv_abi"; break;
1295  OS << "pcs(";
1296  QualType t = T->getEquivalentType();
1297  while (!t->isFunctionType())
1298  t = t->getPointeeType();
1299  OS << (t->getAs<FunctionType>()->getCallConv() == CC_AAPCS ?
1300  "\"aapcs\"" : "\"aapcs-vfp\"");
1301  OS << ')';
1302  break;
1303  }
1304  case AttributedType::attr_inteloclbicc: OS << "inteloclbicc"; break;
1305  }
1306  OS << "))";
1307 }
1308 
1309 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
1310  raw_ostream &OS) {
1311  OS << T->getDecl()->getName();
1312  spaceBeforePlaceHolder(OS);
1313 }
1314 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
1315  raw_ostream &OS) { }
1316 
1317 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
1318  raw_ostream &OS) {
1319  if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1320  !T->isKindOfTypeAsWritten())
1321  return printBefore(T->getBaseType(), OS);
1322 
1323  if (T->isKindOfTypeAsWritten())
1324  OS << "__kindof ";
1325 
1326  print(T->getBaseType(), OS, StringRef());
1327 
1328  if (T->isSpecializedAsWritten()) {
1329  bool isFirst = true;
1330  OS << '<';
1331  for (auto typeArg : T->getTypeArgsAsWritten()) {
1332  if (isFirst)
1333  isFirst = false;
1334  else
1335  OS << ",";
1336 
1337  print(typeArg, OS, StringRef());
1338  }
1339  OS << '>';
1340  }
1341 
1342  if (!T->qual_empty()) {
1343  bool isFirst = true;
1344  OS << '<';
1345  for (const auto *I : T->quals()) {
1346  if (isFirst)
1347  isFirst = false;
1348  else
1349  OS << ',';
1350  OS << I->getName();
1351  }
1352  OS << '>';
1353  }
1354 
1355  spaceBeforePlaceHolder(OS);
1356 }
1357 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
1358  raw_ostream &OS) {
1359  if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1360  !T->isKindOfTypeAsWritten())
1361  return printAfter(T->getBaseType(), OS);
1362 }
1363 
1364 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
1365  raw_ostream &OS) {
1366  printBefore(T->getPointeeType(), OS);
1367 
1368  // If we need to print the pointer, print it now.
1369  if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() &&
1370  !T->isObjCClassType() && !T->isObjCQualifiedClassType()) {
1371  if (HasEmptyPlaceHolder)
1372  OS << ' ';
1373  OS << '*';
1374  }
1375 }
1376 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
1377  raw_ostream &OS) { }
1378 
1379 void TemplateSpecializationType::
1380  PrintTemplateArgumentList(raw_ostream &OS,
1381  const TemplateArgumentListInfo &Args,
1382  const PrintingPolicy &Policy) {
1383  return PrintTemplateArgumentList(OS,
1384  Args.getArgumentArray(),
1385  Args.size(),
1386  Policy);
1387 }
1388 
1389 void
1390 TemplateSpecializationType::PrintTemplateArgumentList(
1391  raw_ostream &OS,
1392  const TemplateArgument *Args,
1393  unsigned NumArgs,
1394  const PrintingPolicy &Policy,
1395  bool SkipBrackets) {
1396  if (!SkipBrackets)
1397  OS << '<';
1398 
1399  bool needSpace = false;
1400  for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
1401  // Print the argument into a string.
1402  SmallString<128> Buf;
1403  llvm::raw_svector_ostream ArgOS(Buf);
1404  if (Args[Arg].getKind() == TemplateArgument::Pack) {
1405  if (Args[Arg].pack_size() && Arg > 0)
1406  OS << ", ";
1407  PrintTemplateArgumentList(ArgOS,
1408  Args[Arg].pack_begin(),
1409  Args[Arg].pack_size(),
1410  Policy, true);
1411  } else {
1412  if (Arg > 0)
1413  OS << ", ";
1414  Args[Arg].print(Policy, ArgOS);
1415  }
1416  StringRef ArgString = ArgOS.str();
1417 
1418  // If this is the first argument and its string representation
1419  // begins with the global scope specifier ('::foo'), add a space
1420  // to avoid printing the diagraph '<:'.
1421  if (!Arg && !ArgString.empty() && ArgString[0] == ':')
1422  OS << ' ';
1423 
1424  OS << ArgString;
1425 
1426  needSpace = (!ArgString.empty() && ArgString.back() == '>');
1427  }
1428 
1429  // If the last character of our string is '>', add another space to
1430  // keep the two '>''s separate tokens. We don't *have* to do this in
1431  // C++0x, but it's still good hygiene.
1432  if (needSpace)
1433  OS << ' ';
1434 
1435  if (!SkipBrackets)
1436  OS << '>';
1437 }
1438 
1439 // Sadly, repeat all that with TemplateArgLoc.
1440 void TemplateSpecializationType::
1441 PrintTemplateArgumentList(raw_ostream &OS,
1442  const TemplateArgumentLoc *Args, unsigned NumArgs,
1443  const PrintingPolicy &Policy) {
1444  OS << '<';
1445 
1446  bool needSpace = false;
1447  for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
1448  if (Arg > 0)
1449  OS << ", ";
1450 
1451  // Print the argument into a string.
1452  SmallString<128> Buf;
1453  llvm::raw_svector_ostream ArgOS(Buf);
1454  if (Args[Arg].getArgument().getKind() == TemplateArgument::Pack) {
1455  PrintTemplateArgumentList(ArgOS,
1456  Args[Arg].getArgument().pack_begin(),
1457  Args[Arg].getArgument().pack_size(),
1458  Policy, true);
1459  } else {
1460  Args[Arg].getArgument().print(Policy, ArgOS);
1461  }
1462  StringRef ArgString = ArgOS.str();
1463 
1464  // If this is the first argument and its string representation
1465  // begins with the global scope specifier ('::foo'), add a space
1466  // to avoid printing the diagraph '<:'.
1467  if (!Arg && !ArgString.empty() && ArgString[0] == ':')
1468  OS << ' ';
1469 
1470  OS << ArgString;
1471 
1472  needSpace = (!ArgString.empty() && ArgString.back() == '>');
1473  }
1474 
1475  // If the last character of our string is '>', add another space to
1476  // keep the two '>''s separate tokens. We don't *have* to do this in
1477  // C++0x, but it's still good hygiene.
1478  if (needSpace)
1479  OS << ' ';
1480 
1481  OS << '>';
1482 }
1483 
1484 std::string Qualifiers::getAsString() const {
1485  LangOptions LO;
1486  return getAsString(PrintingPolicy(LO));
1487 }
1488 
1489 // Appends qualifiers to the given string, separated by spaces. Will
1490 // prefix a space if the string is non-empty. Will not append a final
1491 // space.
1492 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
1493  SmallString<64> Buf;
1494  llvm::raw_svector_ostream StrOS(Buf);
1495  print(StrOS, Policy);
1496  return StrOS.str();
1497 }
1498 
1499 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
1500  if (getCVRQualifiers())
1501  return false;
1502 
1503  if (getAddressSpace())
1504  return false;
1505 
1506  if (getObjCGCAttr())
1507  return false;
1508 
1509  if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
1510  if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
1511  return false;
1512 
1513  return true;
1514 }
1515 
1516 // Appends qualifiers to the given string, separated by spaces. Will
1517 // prefix a space if the string is non-empty. Will not append a final
1518 // space.
1519 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
1520  bool appendSpaceIfNonEmpty) const {
1521  bool addSpace = false;
1522 
1523  unsigned quals = getCVRQualifiers();
1524  if (quals) {
1525  AppendTypeQualList(OS, quals, Policy.LangOpts.C99);
1526  addSpace = true;
1527  }
1528  if (unsigned addrspace = getAddressSpace()) {
1529  if (addSpace)
1530  OS << ' ';
1531  addSpace = true;
1532  switch (addrspace) {
1533  case LangAS::opencl_global:
1534  OS << "__global";
1535  break;
1536  case LangAS::opencl_local:
1537  OS << "__local";
1538  break;
1539  case LangAS::opencl_constant:
1540  OS << "__constant";
1541  break;
1542  case LangAS::opencl_generic:
1543  OS << "__generic";
1544  break;
1545  default:
1546  OS << "__attribute__((address_space(";
1547  OS << addrspace;
1548  OS << ")))";
1549  }
1550  }
1551  if (Qualifiers::GC gc = getObjCGCAttr()) {
1552  if (addSpace)
1553  OS << ' ';
1554  addSpace = true;
1555  if (gc == Qualifiers::Weak)
1556  OS << "__weak";
1557  else
1558  OS << "__strong";
1559  }
1560  if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
1561  if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
1562  if (addSpace)
1563  OS << ' ';
1564  addSpace = true;
1565  }
1566 
1567  switch (lifetime) {
1568  case Qualifiers::OCL_None: llvm_unreachable("none but true");
1569  case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
1570  case Qualifiers::OCL_Strong:
1571  if (!Policy.SuppressStrongLifetime)
1572  OS << "__strong";
1573  break;
1574 
1575  case Qualifiers::OCL_Weak: OS << "__weak"; break;
1576  case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
1577  }
1578  }
1579 
1580  if (appendSpaceIfNonEmpty && addSpace)
1581  OS << ' ';
1582 }
1583 
1584 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
1585  std::string S;
1586  getAsStringInternal(S, Policy);
1587  return S;
1588 }
1589 
1590 std::string QualType::getAsString(const Type *ty, Qualifiers qs) {
1591  std::string buffer;
1592  LangOptions options;
1593  getAsStringInternal(ty, qs, buffer, PrintingPolicy(options));
1594  return buffer;
1595 }
1596 
1597 void QualType::print(const Type *ty, Qualifiers qs,
1598  raw_ostream &OS, const PrintingPolicy &policy,
1599  const Twine &PlaceHolder) {
1600  SmallString<128> PHBuf;
1601  StringRef PH = PlaceHolder.toStringRef(PHBuf);
1602 
1603  TypePrinter(policy).print(ty, qs, OS, PH);
1604 }
1605 
1606 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
1607  std::string &buffer,
1608  const PrintingPolicy &policy) {
1609  SmallString<256> Buf;
1610  llvm::raw_svector_ostream StrOS(Buf);
1611  TypePrinter(policy).print(ty, qs, StrOS, buffer);
1612  std::string str = StrOS.str();
1613  buffer.swap(str);
1614 }
unsigned getNumElements() const
Definition: Type.h:2724
unsigned getAddressSpace() const
getAddressSpace - Return the address space of this type.
Definition: Type.h:5131
static StringRef getKeywordName(ElaboratedTypeKeyword Keyword)
Definition: Type.cpp:2401
bool qual_empty() const
Definition: Type.h:4627
Defines the clang::ASTContext interface.
QualType getExceptionType(unsigned i) const
Definition: Type.h:3194
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:4219
Expr * getSizeExpr() const
Definition: Type.h:2674
const Type * Ty
The locally-unqualified type.
Definition: Type.h:513
ObjCInterfaceDecl * getDecl() const
getDecl - Get the declaration of this interface.
Definition: Type.h:4736
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool SuppressNNS=false) const
Print the template name.
bool isVariadic() const
Definition: Type.h:3228
StringRef getName() const
Definition: Decl.h:168
unsigned getDepth() const
Definition: Type.h:3735
Represents the dependent type named by a dependently-scoped typename using declaration, e.g. using typename Base<T>::foo; Template instantiation turns these into the underlying type.
Definition: Type.h:3305
unsigned getColumn() const
Return the presumed column number of this location.
bool isValid() const
IdentifierInfo * getIdentifier() const
Definition: Decl.h:163
QualType getBaseType() const
Definition: Type.h:3485
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
Definition: Type.h:4645
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4378
Defines the SourceManager interface.
Qualifiers::GC getObjCGCAttr() const
getObjCGCAttr - Returns gc attribute of this type.
Definition: Type.h:5136
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:4285
Defines the C++ template declaration subclasses.
Represents a C++11 auto or C++1y decltype(auto) type.
Definition: Type.h:3874
QualType getPointeeType() const
Definition: Type.h:2364
bool isObjCQualifiedClassType() const
Definition: Type.h:5323
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:400
bool isDecltypeAuto() const
Definition: Type.h:3890
A container of type source information.
Definition: Decl.h:60
unsigned getIndex() const
Definition: Type.h:3736
const llvm::APInt & getSize() const
Definition: Type.h:2472
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:35
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2438
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:3773
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4038
bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType)
unsigned getNumParams() const
Definition: Type.h:3133
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
Definition: Type.h:4313
QualType getElementType() const
Definition: Type.h:2675
Represents a class template specialization, which refers to a class template with a given set of temp...
unsigned getIndexTypeCVRQualifiers() const
Definition: Type.h:2441
unsigned SuppressLifetimeQualifiers
When true, suppress printing of lifetime qualifier in ARC.
Expr * getSizeExpr() const
Definition: Type.h:2568
IdentifierInfo * getIdentifier() const
Definition: Type.cpp:2918
bool isTranslationUnit() const
Definition: DeclBase.h:1243
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:4305
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:212
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:3828
unsigned getRegParm() const
Definition: Type.h:2891
QualType getUnderlyingType() const
Definition: Type.h:3410
Expr * getUnderlyingExpr() const
Definition: Type.h:3430
unsigned SuppressStrongLifetime
When true, suppress printing of the __strong lifetime qualifier in ARC.
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1204
Microsoft throw(...) extension.
QualType getBaseType() const
Definition: Type.h:4569
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4030
QualType getReturnType() const
Definition: Type.h:2952
UnresolvedUsingTypenameDecl * getDecl() const
Definition: Type.h:3315
static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals, bool C99)
TypeOfExprType (GCC extension).
Definition: Type.h:3357
Expr * getNoexceptExpr() const
Definition: Type.h:3198
bool SuppressScope
Suppresses printing of scope specifiers.
Definition: PrettyPrinter.h:90
RecordDecl * getDecl() const
Definition: Type.h:3527
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:4246
TypeClass getTypeClass() const
Definition: Type.h:1486
unsigned getLine() const
Return the presumed line number of this location.
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool appendSpaceIfNonEmpty=false) const
const TemplateSpecializationType * getInjectedTST() const
Definition: Type.h:4113
bool empty() const
Definition: Type.h:356
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:3849
EnumDecl * getDecl() const
Definition: Type.h:3550
QualType getValueType() const
Definition: Type.h:4965
ExtInfo getExtInfo() const
Definition: Type.h:2961
QualType getParamType(unsigned i) const
Definition: Type.h:3134
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3166
Qualifiers::ObjCLifetime getObjCLifetime() const
getObjCLifetime - Returns lifetime attribute of this type.
Definition: Type.h:976
QualType getPointeeType() const
Definition: Type.cpp:414
SplitQualType split() const
Definition: Type.h:5024
QualType getPointeeType() const
Definition: Type.h:2246
Defines the clang::LangOptions interface.
StringRef getName() const
Return the actual identifier string.
bool isObjCClassType() const
Definition: Type.h:5333
bool isObjCGCWeak() const
isObjCGCWeak true when Type is objc's weak.
Definition: Type.h:966
Expr * getUnderlyingExpr() const
Definition: Type.h:3364
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Definition: Type.h:4249
bool getNoReturn() const
Definition: Type.h:2888
DeclContext * getDeclContext()
Definition: DeclBase.h:381
DecltypeType (C++0x)
Definition: Type.h:3422
bool isObjCIdType() const
Definition: Type.h:5328
Kind getAttrKind() const
Definition: Type.h:3634
A unary type transform, which is a type constructed from another.
Definition: Type.h:3463
bool hasTrailingReturn() const
Definition: Type.h:3238
bool isFunctionOrMethod() const
Definition: DeclBase.h:1223
Qualifiers Quals
The local qualifiers.
Definition: Type.h:516
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1174
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:215
Represents an unpacked "presumed" location which can be presented to the user.
QualType getElementType() const
Definition: Type.h:2723
QualType getReplacementType() const
Definition: Type.h:3794
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:2937
bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute. The C++11 [[noreturn]] attr...
Definition: Type.h:2959
const IdentifierInfo * getIdentifier() const
Definition: Type.h:4370
There is no lifetime qualification on this type.
Definition: Type.h:130
#define false
Definition: stdbool.h:33
const char * getFilename() const
Return the presumed filename of this location.
QualType getElementType() const
Definition: Type.h:2077
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:3244
TypeOfType (GCC extension).
Definition: Type.h:3398
bool SuppressSpecifiers
Whether we should suppress printing of the actual specifiers for the given type or declaration...
Definition: PrettyPrinter.h:67
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2694
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:284
VectorKind getVectorKind() const
Definition: Type.h:2732
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1202
bool isSpecializedAsWritten() const
Determine whether this object type was written with type arguments.
Definition: Type.h:4598
TypedefNameDecl * getDecl() const
Definition: Type.h:3348
bool SuppressTagKeyword
Whether type printing should skip printing the tag keyword.
Definition: PrettyPrinter.h:77
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1206
Assigning into this object requires a lifetime extension.
Definition: Type.h:147
UTTKind getUTTKind() const
Definition: Type.h:3487
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2209
The injected class name of a C++ class template or class template partial specialization. Used to record that a type was spelled with a bare identifier rather than as a template-id; the equivalent for non-templated classes is just RecordType.
Definition: Type.h:4082
QualType getPointeeType() const
Definition: Type.h:2139
Represents a pack expansion of types.
Definition: Type.h:4428
ArrayRef< QualType > getTypeArgsAsWritten() const
Definition: Type.h:4615
Expr * getSizeExpr() const
Definition: Type.h:2624
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2576
Represents a template argument.
Definition: TemplateBase.h:39
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2173
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
Print this nested name specifier to the given output stream.
QualType getEquivalentType() const
Definition: Type.h:3639
bool isCallingConv() const
Definition: Type.cpp:2878
CallingConv getCC() const
Definition: Type.h:2897
QualType getModifiedType() const
Definition: Type.h:3638
const TemplateArgument * getArgs() const
Retrieve the template arguments.
Definition: Type.h:4033
const T * getAs() const
Definition: Type.h:5555
unsigned getTypeQuals() const
Definition: Type.h:3240
bool isSpecifierType() const
Definition: Type.cpp:2307
bool isObjCQualifiedIdType() const
Definition: Type.h:5318
bool isFunctionType() const
Definition: Type.h:5229
QualType getInnerType() const
Definition: Type.h:2108
const TemplateArgument * getArgs() const
Retrieve the template arguments.
Definition: Type.h:4373
NestedNameSpecifier * getQualifier() const
Definition: Type.h:4369
bool isMSTypeSpec() const
Definition: Type.cpp:2866
SourceManager & getSourceManager()
Definition: ASTContext.h:494
void printExceptionSpecification(raw_ostream &OS, const PrintingPolicy &Policy) const
A template argument list.
Definition: DeclTemplate.h:150
const Type * getClass() const
Definition: Type.h:2378
Reading or writing from this object requires a barrier call.
Definition: Type.h:144
bool hasQualifiers() const
hasQualifiers - Return true if the set contains any qualifiers.
Definition: Type.h:355
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2435
ElaboratedTypeKeyword getKeyword() const
Definition: Type.h:4177
bool hasDynamicExceptionSpec() const
Return whether this function has a dynamic (throw) exception spec.
Definition: Type.h:3174
QualType getAdjustedType() const
Definition: Type.h:2190
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:4455
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2285
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:3941
QualType getElementType() const
Definition: Type.h:2434
static void PrintTemplateArgumentList(raw_ostream &OS, const TemplateArgument *Args, unsigned NumArgs, const PrintingPolicy &Policy, bool SkipBrackets=false)
Print a template argument list, including the '<' and '>' enclosing the template arguments...
StringRef getKindName() const
Definition: Decl.h:2893
SourceLocation getLocation() const
Definition: DeclBase.h:372
StringRef getName(const PrintingPolicy &Policy) const
Definition: Type.cpp:2474
No keyword precedes the qualified type name.
Definition: Type.h:4158
bool isUnspecializedAsWritten() const
Definition: Type.h:4608
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
StreamedQualTypeHelper stream(const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine()) const
Definition: Type.h:947
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5043
unsigned getNumExceptions() const
Definition: Type.h:3193
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
QualType getDeducedType() const
Get the type deduced for this auto type, or null if it's either not been deduced or was deduced to a ...
Definition: Type.h:3897