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