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