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.inc"
129 
130  private:
131  void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS);
132  void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS);
133  };
134 
135 } // namespace
136 
137 static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals,
138  bool HasRestrictKeyword) {
139  bool appendSpace = false;
140  if (TypeQuals & Qualifiers::Const) {
141  OS << "const";
142  appendSpace = true;
143  }
144  if (TypeQuals & Qualifiers::Volatile) {
145  if (appendSpace) OS << ' ';
146  OS << "volatile";
147  appendSpace = true;
148  }
149  if (TypeQuals & Qualifiers::Restrict) {
150  if (appendSpace) OS << ' ';
151  if (HasRestrictKeyword) {
152  OS << "restrict";
153  } else {
154  OS << "__restrict";
155  }
156  }
157 }
158 
159 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) {
160  if (!HasEmptyPlaceHolder)
161  OS << ' ';
162 }
163 
165  const PrintingPolicy &Policy) {
166  if (Policy.PrintCanonicalTypes)
167  QT = QT.getCanonicalType();
168  return QT.split();
169 }
170 
171 void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) {
172  SplitQualType split = splitAccordingToPolicy(t, Policy);
173  print(split.Ty, split.Quals, OS, PlaceHolder);
174 }
175 
176 void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
177  StringRef PlaceHolder) {
178  if (!T) {
179  OS << "NULL TYPE";
180  return;
181  }
182 
183  SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty());
184 
185  printBefore(T, Quals, OS);
186  OS << PlaceHolder;
187  printAfter(T, Quals, OS);
188 }
189 
190 bool TypePrinter::canPrefixQualifiers(const Type *T,
191  bool &NeedARCStrongQualifier) {
192  // CanPrefixQualifiers - We prefer to print type qualifiers before the type,
193  // so that we get "const int" instead of "int const", but we can't do this if
194  // the type is complex. For example if the type is "int*", we *must* print
195  // "int * const", printing "const int *" is different. Only do this when the
196  // type expands to a simple string.
197  bool CanPrefixQualifiers = false;
198  NeedARCStrongQualifier = false;
199  Type::TypeClass TC = T->getTypeClass();
200  if (const auto *AT = dyn_cast<AutoType>(T))
201  TC = AT->desugar()->getTypeClass();
202  if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(T))
203  TC = Subst->getReplacementType()->getTypeClass();
204 
205  switch (TC) {
206  case Type::Auto:
207  case Type::Builtin:
208  case Type::Complex:
209  case Type::UnresolvedUsing:
210  case Type::Typedef:
211  case Type::TypeOfExpr:
212  case Type::TypeOf:
213  case Type::Decltype:
214  case Type::UnaryTransform:
215  case Type::Record:
216  case Type::Enum:
217  case Type::Elaborated:
218  case Type::TemplateTypeParm:
219  case Type::SubstTemplateTypeParmPack:
220  case Type::DeducedTemplateSpecialization:
221  case Type::TemplateSpecialization:
222  case Type::InjectedClassName:
223  case Type::DependentName:
224  case Type::DependentTemplateSpecialization:
225  case Type::ObjCObject:
226  case Type::ObjCTypeParam:
227  case Type::ObjCInterface:
228  case Type::Atomic:
229  case Type::Pipe:
230  CanPrefixQualifiers = true;
231  break;
232 
233  case Type::ObjCObjectPointer:
234  CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
236  break;
237 
238  case Type::ConstantArray:
239  case Type::IncompleteArray:
240  case Type::VariableArray:
241  case Type::DependentSizedArray:
242  NeedARCStrongQualifier = true;
243  LLVM_FALLTHROUGH;
244 
245  case Type::Adjusted:
246  case Type::Decayed:
247  case Type::Pointer:
248  case Type::BlockPointer:
249  case Type::LValueReference:
250  case Type::RValueReference:
251  case Type::MemberPointer:
252  case Type::DependentAddressSpace:
253  case Type::DependentVector:
254  case Type::DependentSizedExtVector:
255  case Type::Vector:
256  case Type::ExtVector:
257  case Type::FunctionProto:
258  case Type::FunctionNoProto:
259  case Type::Paren:
260  case Type::PackExpansion:
261  case Type::SubstTemplateTypeParm:
262  case Type::MacroQualified:
263  CanPrefixQualifiers = false;
264  break;
265 
266  case Type::Attributed: {
267  // We still want to print the address_space before the type if it is an
268  // address_space attribute.
269  const auto *AttrTy = cast<AttributedType>(T);
270  CanPrefixQualifiers = AttrTy->getAttrKind() == attr::AddressSpace;
271  }
272  }
273 
274  return CanPrefixQualifiers;
275 }
276 
277 void TypePrinter::printBefore(QualType T, raw_ostream &OS) {
279 
280  // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2
281  // at this level.
282  Qualifiers Quals = Split.Quals;
283  if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(Split.Ty))
284  Quals -= QualType(Subst, 0).getQualifiers();
285 
286  printBefore(Split.Ty, Quals, OS);
287 }
288 
289 /// Prints the part of the type string before an identifier, e.g. for
290 /// "int foo[10]" it prints "int ".
291 void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) {
292  if (Policy.SuppressSpecifiers && T->isSpecifierType())
293  return;
294 
295  SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder);
296 
297  // Print qualifiers as appropriate.
298 
299  bool CanPrefixQualifiers = false;
300  bool NeedARCStrongQualifier = false;
301  CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier);
302 
303  if (CanPrefixQualifiers && !Quals.empty()) {
304  if (NeedARCStrongQualifier) {
305  IncludeStrongLifetimeRAII Strong(Policy);
306  Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
307  } else {
308  Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
309  }
310  }
311 
312  bool hasAfterQuals = false;
313  if (!CanPrefixQualifiers && !Quals.empty()) {
314  hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy);
315  if (hasAfterQuals)
316  HasEmptyPlaceHolder = false;
317  }
318 
319  switch (T->getTypeClass()) {
320 #define ABSTRACT_TYPE(CLASS, PARENT)
321 #define TYPE(CLASS, PARENT) case Type::CLASS: \
322  print##CLASS##Before(cast<CLASS##Type>(T), OS); \
323  break;
324 #include "clang/AST/TypeNodes.inc"
325  }
326 
327  if (hasAfterQuals) {
328  if (NeedARCStrongQualifier) {
329  IncludeStrongLifetimeRAII Strong(Policy);
330  Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
331  } else {
332  Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
333  }
334  }
335 }
336 
337 void TypePrinter::printAfter(QualType t, raw_ostream &OS) {
338  SplitQualType split = splitAccordingToPolicy(t, Policy);
339  printAfter(split.Ty, split.Quals, OS);
340 }
341 
342 /// Prints the part of the type string after an identifier, e.g. for
343 /// "int foo[10]" it prints "[10]".
344 void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) {
345  switch (T->getTypeClass()) {
346 #define ABSTRACT_TYPE(CLASS, PARENT)
347 #define TYPE(CLASS, PARENT) case Type::CLASS: \
348  print##CLASS##After(cast<CLASS##Type>(T), OS); \
349  break;
350 #include "clang/AST/TypeNodes.inc"
351  }
352 }
353 
354 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) {
355  OS << T->getName(Policy);
356  spaceBeforePlaceHolder(OS);
357 }
358 
359 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {}
360 
361 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) {
362  OS << "_Complex ";
363  printBefore(T->getElementType(), OS);
364 }
365 
366 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) {
367  printAfter(T->getElementType(), OS);
368 }
369 
370 void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) {
371  IncludeStrongLifetimeRAII Strong(Policy);
372  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
373  printBefore(T->getPointeeType(), OS);
374  // Handle things like 'int (*A)[4];' correctly.
375  // FIXME: this should include vectors, but vectors use attributes I guess.
376  if (isa<ArrayType>(T->getPointeeType()))
377  OS << '(';
378  OS << '*';
379 }
380 
381 void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) {
382  IncludeStrongLifetimeRAII Strong(Policy);
383  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
384  // Handle things like 'int (*A)[4];' correctly.
385  // FIXME: this should include vectors, but vectors use attributes I guess.
386  if (isa<ArrayType>(T->getPointeeType()))
387  OS << ')';
388  printAfter(T->getPointeeType(), OS);
389 }
390 
391 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T,
392  raw_ostream &OS) {
393  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
394  printBefore(T->getPointeeType(), OS);
395  OS << '^';
396 }
397 
398 void TypePrinter::printBlockPointerAfter(const BlockPointerType *T,
399  raw_ostream &OS) {
400  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
401  printAfter(T->getPointeeType(), OS);
402 }
403 
404 // When printing a reference, the referenced type might also be a reference.
405 // If so, we want to skip that before printing the inner type.
407  if (auto *Ref = T->getAs<ReferenceType>())
408  return skipTopLevelReferences(Ref->getPointeeTypeAsWritten());
409  return T;
410 }
411 
412 void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T,
413  raw_ostream &OS) {
414  IncludeStrongLifetimeRAII Strong(Policy);
415  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
417  printBefore(Inner, OS);
418  // Handle things like 'int (&A)[4];' correctly.
419  // FIXME: this should include vectors, but vectors use attributes I guess.
420  if (isa<ArrayType>(Inner))
421  OS << '(';
422  OS << '&';
423 }
424 
425 void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T,
426  raw_ostream &OS) {
427  IncludeStrongLifetimeRAII Strong(Policy);
428  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
430  // Handle things like 'int (&A)[4];' correctly.
431  // FIXME: this should include vectors, but vectors use attributes I guess.
432  if (isa<ArrayType>(Inner))
433  OS << ')';
434  printAfter(Inner, OS);
435 }
436 
437 void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T,
438  raw_ostream &OS) {
439  IncludeStrongLifetimeRAII Strong(Policy);
440  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
442  printBefore(Inner, OS);
443  // Handle things like 'int (&&A)[4];' correctly.
444  // FIXME: this should include vectors, but vectors use attributes I guess.
445  if (isa<ArrayType>(Inner))
446  OS << '(';
447  OS << "&&";
448 }
449 
450 void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T,
451  raw_ostream &OS) {
452  IncludeStrongLifetimeRAII Strong(Policy);
453  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
455  // Handle things like 'int (&&A)[4];' correctly.
456  // FIXME: this should include vectors, but vectors use attributes I guess.
457  if (isa<ArrayType>(Inner))
458  OS << ')';
459  printAfter(Inner, OS);
460 }
461 
462 void TypePrinter::printMemberPointerBefore(const MemberPointerType *T,
463  raw_ostream &OS) {
464  IncludeStrongLifetimeRAII Strong(Policy);
465  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
466  printBefore(T->getPointeeType(), OS);
467  // Handle things like 'int (Cls::*A)[4];' correctly.
468  // FIXME: this should include vectors, but vectors use attributes I guess.
469  if (isa<ArrayType>(T->getPointeeType()))
470  OS << '(';
471 
472  PrintingPolicy InnerPolicy(Policy);
473  InnerPolicy.IncludeTagDefinition = false;
474  TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef());
475 
476  OS << "::*";
477 }
478 
479 void TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
480  raw_ostream &OS) {
481  IncludeStrongLifetimeRAII Strong(Policy);
482  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
483  // Handle things like 'int (Cls::*A)[4];' correctly.
484  // FIXME: this should include vectors, but vectors use attributes I guess.
485  if (isa<ArrayType>(T->getPointeeType()))
486  OS << ')';
487  printAfter(T->getPointeeType(), OS);
488 }
489 
490 void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T,
491  raw_ostream &OS) {
492  IncludeStrongLifetimeRAII Strong(Policy);
493  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
494  printBefore(T->getElementType(), OS);
495 }
496 
497 void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
498  raw_ostream &OS) {
499  OS << '[';
502  Policy.Restrict);
503  OS << ' ';
504  }
505 
507  OS << "static ";
508 
509  OS << T->getSize().getZExtValue() << ']';
510  printAfter(T->getElementType(), OS);
511 }
512 
513 void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T,
514  raw_ostream &OS) {
515  IncludeStrongLifetimeRAII Strong(Policy);
516  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
517  printBefore(T->getElementType(), OS);
518 }
519 
520 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
521  raw_ostream &OS) {
522  OS << "[]";
523  printAfter(T->getElementType(), OS);
524 }
525 
526 void TypePrinter::printVariableArrayBefore(const VariableArrayType *T,
527  raw_ostream &OS) {
528  IncludeStrongLifetimeRAII Strong(Policy);
529  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
530  printBefore(T->getElementType(), OS);
531 }
532 
533 void TypePrinter::printVariableArrayAfter(const VariableArrayType *T,
534  raw_ostream &OS) {
535  OS << '[';
537  AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.Restrict);
538  OS << ' ';
539  }
540 
542  OS << "static ";
543  else if (T->getSizeModifier() == VariableArrayType::Star)
544  OS << '*';
545 
546  if (T->getSizeExpr())
547  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
548  OS << ']';
549 
550  printAfter(T->getElementType(), OS);
551 }
552 
553 void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) {
554  // Print the adjusted representation, otherwise the adjustment will be
555  // invisible.
556  printBefore(T->getAdjustedType(), OS);
557 }
558 
559 void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) {
560  printAfter(T->getAdjustedType(), OS);
561 }
562 
563 void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) {
564  // Print as though it's a pointer.
565  printAdjustedBefore(T, OS);
566 }
567 
568 void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) {
569  printAdjustedAfter(T, OS);
570 }
571 
572 void TypePrinter::printDependentSizedArrayBefore(
573  const DependentSizedArrayType *T,
574  raw_ostream &OS) {
575  IncludeStrongLifetimeRAII Strong(Policy);
576  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
577  printBefore(T->getElementType(), OS);
578 }
579 
580 void TypePrinter::printDependentSizedArrayAfter(
581  const DependentSizedArrayType *T,
582  raw_ostream &OS) {
583  OS << '[';
584  if (T->getSizeExpr())
585  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
586  OS << ']';
587  printAfter(T->getElementType(), OS);
588 }
589 
590 void TypePrinter::printDependentAddressSpaceBefore(
591  const DependentAddressSpaceType *T, raw_ostream &OS) {
592  printBefore(T->getPointeeType(), OS);
593 }
594 
595 void TypePrinter::printDependentAddressSpaceAfter(
596  const DependentAddressSpaceType *T, raw_ostream &OS) {
597  OS << " __attribute__((address_space(";
598  if (T->getAddrSpaceExpr())
599  T->getAddrSpaceExpr()->printPretty(OS, nullptr, Policy);
600  OS << ")))";
601  printAfter(T->getPointeeType(), OS);
602 }
603 
604 void TypePrinter::printDependentSizedExtVectorBefore(
606  raw_ostream &OS) {
607  printBefore(T->getElementType(), OS);
608 }
609 
610 void TypePrinter::printDependentSizedExtVectorAfter(
612  raw_ostream &OS) {
613  OS << " __attribute__((ext_vector_type(";
614  if (T->getSizeExpr())
615  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
616  OS << ")))";
617  printAfter(T->getElementType(), OS);
618 }
619 
620 void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) {
621  switch (T->getVectorKind()) {
623  OS << "__vector __pixel ";
624  break;
626  OS << "__vector __bool ";
627  printBefore(T->getElementType(), OS);
628  break;
630  OS << "__vector ";
631  printBefore(T->getElementType(), OS);
632  break;
634  OS << "__attribute__((neon_vector_type("
635  << T->getNumElements() << "))) ";
636  printBefore(T->getElementType(), OS);
637  break;
639  OS << "__attribute__((neon_polyvector_type(" <<
640  T->getNumElements() << "))) ";
641  printBefore(T->getElementType(), OS);
642  break;
644  // FIXME: We prefer to print the size directly here, but have no way
645  // to get the size of the type.
646  OS << "__attribute__((__vector_size__("
647  << T->getNumElements()
648  << " * sizeof(";
649  print(T->getElementType(), OS, StringRef());
650  OS << ")))) ";
651  printBefore(T->getElementType(), OS);
652  break;
653  }
654  }
655 }
656 
657 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) {
658  printAfter(T->getElementType(), OS);
659 }
660 
661 void TypePrinter::printDependentVectorBefore(
662  const DependentVectorType *T, raw_ostream &OS) {
663  switch (T->getVectorKind()) {
665  OS << "__vector __pixel ";
666  break;
668  OS << "__vector __bool ";
669  printBefore(T->getElementType(), OS);
670  break;
672  OS << "__vector ";
673  printBefore(T->getElementType(), OS);
674  break;
676  OS << "__attribute__((neon_vector_type(";
677  if (T->getSizeExpr())
678  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
679  OS << "))) ";
680  printBefore(T->getElementType(), OS);
681  break;
683  OS << "__attribute__((neon_polyvector_type(";
684  if (T->getSizeExpr())
685  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
686  OS << "))) ";
687  printBefore(T->getElementType(), OS);
688  break;
690  // FIXME: We prefer to print the size directly here, but have no way
691  // to get the size of the type.
692  OS << "__attribute__((__vector_size__(";
693  if (T->getSizeExpr())
694  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
695  OS << " * sizeof(";
696  print(T->getElementType(), OS, StringRef());
697  OS << ")))) ";
698  printBefore(T->getElementType(), OS);
699  break;
700  }
701  }
702 }
703 
704 void TypePrinter::printDependentVectorAfter(
705  const DependentVectorType *T, raw_ostream &OS) {
706  printAfter(T->getElementType(), OS);
707 }
708 
709 void TypePrinter::printExtVectorBefore(const ExtVectorType *T,
710  raw_ostream &OS) {
711  printBefore(T->getElementType(), OS);
712 }
713 
714 void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) {
715  printAfter(T->getElementType(), OS);
716  OS << " __attribute__((ext_vector_type(";
717  OS << T->getNumElements();
718  OS << ")))";
719 }
720 
721 void
723  const PrintingPolicy &Policy)
724  const {
725  if (hasDynamicExceptionSpec()) {
726  OS << " throw(";
727  if (getExceptionSpecType() == EST_MSAny)
728  OS << "...";
729  else
730  for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) {
731  if (I)
732  OS << ", ";
733 
734  OS << getExceptionType(I).stream(Policy);
735  }
736  OS << ')';
737  } else if (EST_NoThrow == getExceptionSpecType()) {
738  OS << " __attribute__((nothrow))";
739  } else if (isNoexceptExceptionSpec(getExceptionSpecType())) {
740  OS << " noexcept";
741  // FIXME:Is it useful to print out the expression for a non-dependent
742  // noexcept specification?
743  if (isComputedNoexcept(getExceptionSpecType())) {
744  OS << '(';
745  if (getNoexceptExpr())
746  getNoexceptExpr()->printPretty(OS, nullptr, Policy);
747  OS << ')';
748  }
749  }
750 }
751 
752 void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T,
753  raw_ostream &OS) {
754  if (T->hasTrailingReturn()) {
755  OS << "auto ";
756  if (!HasEmptyPlaceHolder)
757  OS << '(';
758  } else {
759  // If needed for precedence reasons, wrap the inner part in grouping parens.
760  SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
761  printBefore(T->getReturnType(), OS);
762  if (!PrevPHIsEmpty.get())
763  OS << '(';
764  }
765 }
766 
768  switch (ABI) {
770  llvm_unreachable("asking for spelling of ordinary parameter ABI");
772  return "swift_context";
774  return "swift_error_result";
776  return "swift_indirect_result";
777  }
778  llvm_unreachable("bad parameter ABI kind");
779 }
780 
781 void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
782  raw_ostream &OS) {
783  // If needed for precedence reasons, wrap the inner part in grouping parens.
784  if (!HasEmptyPlaceHolder)
785  OS << ')';
786  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
787 
788  OS << '(';
789  {
790  ParamPolicyRAII ParamPolicy(Policy);
791  for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) {
792  if (i) OS << ", ";
793 
794  auto EPI = T->getExtParameterInfo(i);
795  if (EPI.isConsumed()) OS << "__attribute__((ns_consumed)) ";
796  if (EPI.isNoEscape())
797  OS << "__attribute__((noescape)) ";
798  auto ABI = EPI.getABI();
799  if (ABI != ParameterABI::Ordinary)
800  OS << "__attribute__((" << getParameterABISpelling(ABI) << ")) ";
801 
802  print(T->getParamType(i), OS, StringRef());
803  }
804  }
805 
806  if (T->isVariadic()) {
807  if (T->getNumParams())
808  OS << ", ";
809  OS << "...";
810  } else if (T->getNumParams() == 0 && Policy.UseVoidForZeroParams) {
811  // Do not emit int() if we have a proto, emit 'int(void)'.
812  OS << "void";
813  }
814 
815  OS << ')';
816 
817  FunctionType::ExtInfo Info = T->getExtInfo();
818 
819  printFunctionAfter(Info, OS);
820 
821  if (!T->getMethodQuals().empty())
822  OS << " " << T->getMethodQuals().getAsString();
823 
824  switch (T->getRefQualifier()) {
825  case RQ_None:
826  break;
827 
828  case RQ_LValue:
829  OS << " &";
830  break;
831 
832  case RQ_RValue:
833  OS << " &&";
834  break;
835  }
836  T->printExceptionSpecification(OS, Policy);
837 
838  if (T->hasTrailingReturn()) {
839  OS << " -> ";
840  print(T->getReturnType(), OS, StringRef());
841  } else
842  printAfter(T->getReturnType(), OS);
843 }
844 
845 void TypePrinter::printFunctionAfter(const FunctionType::ExtInfo &Info,
846  raw_ostream &OS) {
847  if (!InsideCCAttribute) {
848  switch (Info.getCC()) {
849  case CC_C:
850  // The C calling convention is the default on the vast majority of platforms
851  // we support. If the user wrote it explicitly, it will usually be printed
852  // while traversing the AttributedType. If the type has been desugared, let
853  // the canonical spelling be the implicit calling convention.
854  // FIXME: It would be better to be explicit in certain contexts, such as a
855  // cdecl function typedef used to declare a member function with the
856  // Microsoft C++ ABI.
857  break;
858  case CC_X86StdCall:
859  OS << " __attribute__((stdcall))";
860  break;
861  case CC_X86FastCall:
862  OS << " __attribute__((fastcall))";
863  break;
864  case CC_X86ThisCall:
865  OS << " __attribute__((thiscall))";
866  break;
867  case CC_X86VectorCall:
868  OS << " __attribute__((vectorcall))";
869  break;
870  case CC_X86Pascal:
871  OS << " __attribute__((pascal))";
872  break;
873  case CC_AAPCS:
874  OS << " __attribute__((pcs(\"aapcs\")))";
875  break;
876  case CC_AAPCS_VFP:
877  OS << " __attribute__((pcs(\"aapcs-vfp\")))";
878  break;
880  OS << "__attribute__((aarch64_vector_pcs))";
881  break;
882  case CC_IntelOclBicc:
883  OS << " __attribute__((intel_ocl_bicc))";
884  break;
885  case CC_Win64:
886  OS << " __attribute__((ms_abi))";
887  break;
888  case CC_X86_64SysV:
889  OS << " __attribute__((sysv_abi))";
890  break;
891  case CC_X86RegCall:
892  OS << " __attribute__((regcall))";
893  break;
894  case CC_SpirFunction:
895  case CC_OpenCLKernel:
896  // Do nothing. These CCs are not available as attributes.
897  break;
898  case CC_Swift:
899  OS << " __attribute__((swiftcall))";
900  break;
901  case CC_PreserveMost:
902  OS << " __attribute__((preserve_most))";
903  break;
904  case CC_PreserveAll:
905  OS << " __attribute__((preserve_all))";
906  break;
907  }
908  }
909 
910  if (Info.getNoReturn())
911  OS << " __attribute__((noreturn))";
912  if (Info.getProducesResult())
913  OS << " __attribute__((ns_returns_retained))";
914  if (Info.getRegParm())
915  OS << " __attribute__((regparm ("
916  << Info.getRegParm() << ")))";
917  if (Info.getNoCallerSavedRegs())
918  OS << " __attribute__((no_caller_saved_registers))";
919  if (Info.getNoCfCheck())
920  OS << " __attribute__((nocf_check))";
921 }
922 
923 void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T,
924  raw_ostream &OS) {
925  // If needed for precedence reasons, wrap the inner part in grouping parens.
926  SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
927  printBefore(T->getReturnType(), OS);
928  if (!PrevPHIsEmpty.get())
929  OS << '(';
930 }
931 
932 void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T,
933  raw_ostream &OS) {
934  // If needed for precedence reasons, wrap the inner part in grouping parens.
935  if (!HasEmptyPlaceHolder)
936  OS << ')';
937  SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
938 
939  OS << "()";
940  printFunctionAfter(T->getExtInfo(), OS);
941  printAfter(T->getReturnType(), OS);
942 }
943 
944 void TypePrinter::printTypeSpec(NamedDecl *D, raw_ostream &OS) {
945 
946  // Compute the full nested-name-specifier for this type.
947  // In C, this will always be empty except when the type
948  // being printed is anonymous within other Record.
949  if (!Policy.SuppressScope)
950  AppendScope(D->getDeclContext(), OS);
951 
952  IdentifierInfo *II = D->getIdentifier();
953  OS << II->getName();
954  spaceBeforePlaceHolder(OS);
955 }
956 
957 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
958  raw_ostream &OS) {
959  printTypeSpec(T->getDecl(), OS);
960 }
961 
962 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
963  raw_ostream &OS) {}
964 
965 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
966  printTypeSpec(T->getDecl(), OS);
967 }
968 
969 void TypePrinter::printMacroQualifiedBefore(const MacroQualifiedType *T,
970  raw_ostream &OS) {
971  StringRef MacroName = T->getMacroIdentifier()->getName();
972  OS << MacroName << " ";
973 
974  // Since this type is meant to print the macro instead of the whole attribute,
975  // we trim any attributes and go directly to the original modified type.
976  printBefore(T->getModifiedType(), OS);
977 }
978 
979 void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T,
980  raw_ostream &OS) {
981  printAfter(T->getModifiedType(), OS);
982 }
983 
984 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {}
985 
986 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
987  raw_ostream &OS) {
988  OS << "typeof ";
989  if (T->getUnderlyingExpr())
990  T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
991  spaceBeforePlaceHolder(OS);
992 }
993 
994 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
995  raw_ostream &OS) {}
996 
997 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
998  OS << "typeof(";
999  print(T->getUnderlyingType(), OS, StringRef());
1000  OS << ')';
1001  spaceBeforePlaceHolder(OS);
1002 }
1003 
1004 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {}
1005 
1006 void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
1007  OS << "decltype(";
1008  if (T->getUnderlyingExpr())
1009  T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
1010  OS << ')';
1011  spaceBeforePlaceHolder(OS);
1012 }
1013 
1014 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}
1015 
1016 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
1017  raw_ostream &OS) {
1018  IncludeStrongLifetimeRAII Strong(Policy);
1019 
1020  switch (T->getUTTKind()) {
1022  OS << "__underlying_type(";
1023  print(T->getBaseType(), OS, StringRef());
1024  OS << ')';
1025  spaceBeforePlaceHolder(OS);
1026  return;
1027  }
1028 
1029  printBefore(T->getBaseType(), OS);
1030 }
1031 
1032 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
1033  raw_ostream &OS) {
1034  IncludeStrongLifetimeRAII Strong(Policy);
1035 
1036  switch (T->getUTTKind()) {
1038  return;
1039  }
1040 
1041  printAfter(T->getBaseType(), OS);
1042 }
1043 
1044 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
1045  // If the type has been deduced, do not print 'auto'.
1046  if (!T->getDeducedType().isNull()) {
1047  printBefore(T->getDeducedType(), OS);
1048  } else {
1049  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  TypeSourceInfo *TAW = Spec->getTypeAsWritten();
1208  if (!Policy.PrintCanonicalTypes && TAW) {
1209  const TemplateSpecializationType *TST =
1210  cast<TemplateSpecializationType>(TAW->getType());
1211  Args = TST->template_arguments();
1212  } else {
1213  const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1214  Args = TemplateArgs.asArray();
1215  }
1216  IncludeStrongLifetimeRAII Strong(Policy);
1217  printTemplateArgumentList(OS, Args, Policy);
1218  }
1219 
1220  spaceBeforePlaceHolder(OS);
1221 }
1222 
1223 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
1224  printTag(T->getDecl(), OS);
1225 }
1226 
1227 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {}
1228 
1229 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
1230  printTag(T->getDecl(), OS);
1231 }
1232 
1233 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {}
1234 
1235 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
1236  raw_ostream &OS) {
1237  if (IdentifierInfo *Id = T->getIdentifier())
1238  OS << Id->getName();
1239  else {
1240  bool IsLambdaAutoParam = false;
1241  if (auto D = T->getDecl()) {
1242  if (auto M = dyn_cast_or_null<CXXMethodDecl>(D->getDeclContext()))
1243  IsLambdaAutoParam = D->isImplicit() && M->getParent()->isLambda();
1244  }
1245 
1246  if (IsLambdaAutoParam)
1247  OS << "auto";
1248  else
1249  OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
1250  }
1251  spaceBeforePlaceHolder(OS);
1252 }
1253 
1254 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
1255  raw_ostream &OS) {}
1256 
1257 void TypePrinter::printSubstTemplateTypeParmBefore(
1258  const SubstTemplateTypeParmType *T,
1259  raw_ostream &OS) {
1260  IncludeStrongLifetimeRAII Strong(Policy);
1261  printBefore(T->getReplacementType(), OS);
1262 }
1263 
1264 void TypePrinter::printSubstTemplateTypeParmAfter(
1265  const SubstTemplateTypeParmType *T,
1266  raw_ostream &OS) {
1267  IncludeStrongLifetimeRAII Strong(Policy);
1268  printAfter(T->getReplacementType(), OS);
1269 }
1270 
1271 void TypePrinter::printSubstTemplateTypeParmPackBefore(
1273  raw_ostream &OS) {
1274  IncludeStrongLifetimeRAII Strong(Policy);
1275  printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1276 }
1277 
1278 void TypePrinter::printSubstTemplateTypeParmPackAfter(
1280  raw_ostream &OS) {
1281  IncludeStrongLifetimeRAII Strong(Policy);
1282  printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1283 }
1284 
1285 void TypePrinter::printTemplateSpecializationBefore(
1286  const TemplateSpecializationType *T,
1287  raw_ostream &OS) {
1288  IncludeStrongLifetimeRAII Strong(Policy);
1289  T->getTemplateName().print(OS, Policy);
1290 
1292  spaceBeforePlaceHolder(OS);
1293 }
1294 
1295 void TypePrinter::printTemplateSpecializationAfter(
1296  const TemplateSpecializationType *T,
1297  raw_ostream &OS) {}
1298 
1299 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
1300  raw_ostream &OS) {
1301  printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1302 }
1303 
1304 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
1305  raw_ostream &OS) {}
1306 
1307 void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
1308  raw_ostream &OS) {
1309  if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) {
1310  TagDecl *OwnedTagDecl = T->getOwnedTagDecl();
1311  assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() &&
1312  "OwnedTagDecl expected to be a declaration for the type");
1313  PrintingPolicy SubPolicy = Policy;
1314  SubPolicy.IncludeTagDefinition = false;
1315  OwnedTagDecl->print(OS, SubPolicy, Indentation);
1316  spaceBeforePlaceHolder(OS);
1317  return;
1318  }
1319 
1320  // The tag definition will take care of these.
1321  if (!Policy.IncludeTagDefinition)
1322  {
1324  if (T->getKeyword() != ETK_None)
1325  OS << " ";
1326  NestedNameSpecifier *Qualifier = T->getQualifier();
1327  if (Qualifier)
1328  Qualifier->print(OS, Policy);
1329  }
1330 
1331  ElaboratedTypePolicyRAII PolicyRAII(Policy);
1332  printBefore(T->getNamedType(), OS);
1333 }
1334 
1335 void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
1336  raw_ostream &OS) {
1337  if (Policy.IncludeTagDefinition && T->getOwnedTagDecl())
1338  return;
1339  ElaboratedTypePolicyRAII PolicyRAII(Policy);
1340  printAfter(T->getNamedType(), OS);
1341 }
1342 
1343 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
1344  if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1345  printBefore(T->getInnerType(), OS);
1346  OS << '(';
1347  } else
1348  printBefore(T->getInnerType(), OS);
1349 }
1350 
1351 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
1352  if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1353  OS << ')';
1354  printAfter(T->getInnerType(), OS);
1355  } else
1356  printAfter(T->getInnerType(), OS);
1357 }
1358 
1359 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
1360  raw_ostream &OS) {
1362  if (T->getKeyword() != ETK_None)
1363  OS << " ";
1364 
1365  T->getQualifier()->print(OS, Policy);
1366 
1367  OS << T->getIdentifier()->getName();
1368  spaceBeforePlaceHolder(OS);
1369 }
1370 
1371 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
1372  raw_ostream &OS) {}
1373 
1374 void TypePrinter::printDependentTemplateSpecializationBefore(
1375  const DependentTemplateSpecializationType *T, raw_ostream &OS) {
1376  IncludeStrongLifetimeRAII Strong(Policy);
1377 
1379  if (T->getKeyword() != ETK_None)
1380  OS << " ";
1381 
1382  if (T->getQualifier())
1383  T->getQualifier()->print(OS, Policy);
1384  OS << T->getIdentifier()->getName();
1386  spaceBeforePlaceHolder(OS);
1387 }
1388 
1389 void TypePrinter::printDependentTemplateSpecializationAfter(
1390  const DependentTemplateSpecializationType *T, raw_ostream &OS) {}
1391 
1392 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
1393  raw_ostream &OS) {
1394  printBefore(T->getPattern(), OS);
1395 }
1396 
1397 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
1398  raw_ostream &OS) {
1399  printAfter(T->getPattern(), OS);
1400  OS << "...";
1401 }
1402 
1403 void TypePrinter::printAttributedBefore(const AttributedType *T,
1404  raw_ostream &OS) {
1405  // FIXME: Generate this with TableGen.
1406 
1407  // Prefer the macro forms of the GC and ownership qualifiers.
1408  if (T->getAttrKind() == attr::ObjCGC ||
1409  T->getAttrKind() == attr::ObjCOwnership)
1410  return printBefore(T->getEquivalentType(), OS);
1411 
1412  if (T->getAttrKind() == attr::ObjCKindOf)
1413  OS << "__kindof ";
1414 
1415  if (T->getAttrKind() == attr::AddressSpace)
1416  printBefore(T->getEquivalentType(), OS);
1417  else
1418  printBefore(T->getModifiedType(), OS);
1419 
1420  if (T->isMSTypeSpec()) {
1421  switch (T->getAttrKind()) {
1422  default: return;
1423  case attr::Ptr32: OS << " __ptr32"; break;
1424  case attr::Ptr64: OS << " __ptr64"; break;
1425  case attr::SPtr: OS << " __sptr"; break;
1426  case attr::UPtr: OS << " __uptr"; break;
1427  }
1428  spaceBeforePlaceHolder(OS);
1429  }
1430 
1431  // Print nullability type specifiers.
1432  if (T->getImmediateNullability()) {
1433  if (T->getAttrKind() == attr::TypeNonNull)
1434  OS << " _Nonnull";
1435  else if (T->getAttrKind() == attr::TypeNullable)
1436  OS << " _Nullable";
1437  else if (T->getAttrKind() == attr::TypeNullUnspecified)
1438  OS << " _Null_unspecified";
1439  else
1440  llvm_unreachable("unhandled nullability");
1441  spaceBeforePlaceHolder(OS);
1442  }
1443 }
1444 
1445 void TypePrinter::printAttributedAfter(const AttributedType *T,
1446  raw_ostream &OS) {
1447  // FIXME: Generate this with TableGen.
1448 
1449  // Prefer the macro forms of the GC and ownership qualifiers.
1450  if (T->getAttrKind() == attr::ObjCGC ||
1451  T->getAttrKind() == attr::ObjCOwnership)
1452  return printAfter(T->getEquivalentType(), OS);
1453 
1454  // If this is a calling convention attribute, don't print the implicit CC from
1455  // the modified type.
1456  SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv());
1457 
1458  printAfter(T->getModifiedType(), OS);
1459 
1460  // Some attributes are printed as qualifiers before the type, so we have
1461  // nothing left to do.
1462  if (T->getAttrKind() == attr::ObjCKindOf ||
1464  return;
1465 
1466  // Don't print the inert __unsafe_unretained attribute at all.
1467  if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained)
1468  return;
1469 
1470  // Don't print ns_returns_retained unless it had an effect.
1471  if (T->getAttrKind() == attr::NSReturnsRetained &&
1473  ->getExtInfo().getProducesResult())
1474  return;
1475 
1476  if (T->getAttrKind() == attr::LifetimeBound) {
1477  OS << " [[clang::lifetimebound]]";
1478  return;
1479  }
1480 
1481  // The printing of the address_space attribute is handled by the qualifier
1482  // since it is still stored in the qualifier. Return early to prevent printing
1483  // this twice.
1484  if (T->getAttrKind() == attr::AddressSpace)
1485  return;
1486 
1487  OS << " __attribute__((";
1488  switch (T->getAttrKind()) {
1489 #define TYPE_ATTR(NAME)
1490 #define DECL_OR_TYPE_ATTR(NAME)
1491 #define ATTR(NAME) case attr::NAME:
1492 #include "clang/Basic/AttrList.inc"
1493  llvm_unreachable("non-type attribute attached to type");
1494 
1495  case attr::OpenCLPrivateAddressSpace:
1496  case attr::OpenCLGlobalAddressSpace:
1497  case attr::OpenCLLocalAddressSpace:
1498  case attr::OpenCLConstantAddressSpace:
1499  case attr::OpenCLGenericAddressSpace:
1500  // FIXME: Update printAttributedBefore to print these once we generate
1501  // AttributedType nodes for them.
1502  break;
1503 
1504  case attr::LifetimeBound:
1505  case attr::TypeNonNull:
1506  case attr::TypeNullable:
1507  case attr::TypeNullUnspecified:
1508  case attr::ObjCGC:
1509  case attr::ObjCInertUnsafeUnretained:
1510  case attr::ObjCKindOf:
1511  case attr::ObjCOwnership:
1512  case attr::Ptr32:
1513  case attr::Ptr64:
1514  case attr::SPtr:
1515  case attr::UPtr:
1516  case attr::AddressSpace:
1517  llvm_unreachable("This attribute should have been handled already");
1518 
1519  case attr::NSReturnsRetained:
1520  OS << "ns_returns_retained";
1521  break;
1522 
1523  // FIXME: When Sema learns to form this AttributedType, avoid printing the
1524  // attribute again in printFunctionProtoAfter.
1525  case attr::AnyX86NoCfCheck: OS << "nocf_check"; break;
1526  case attr::CDecl: OS << "cdecl"; break;
1527  case attr::FastCall: OS << "fastcall"; break;
1528  case attr::StdCall: OS << "stdcall"; break;
1529  case attr::ThisCall: OS << "thiscall"; break;
1530  case attr::SwiftCall: OS << "swiftcall"; break;
1531  case attr::VectorCall: OS << "vectorcall"; break;
1532  case attr::Pascal: OS << "pascal"; break;
1533  case attr::MSABI: OS << "ms_abi"; break;
1534  case attr::SysVABI: OS << "sysv_abi"; break;
1535  case attr::RegCall: OS << "regcall"; break;
1536  case attr::Pcs: {
1537  OS << "pcs(";
1538  QualType t = T->getEquivalentType();
1539  while (!t->isFunctionType())
1540  t = t->getPointeeType();
1541  OS << (t->castAs<FunctionType>()->getCallConv() == CC_AAPCS ?
1542  "\"aapcs\"" : "\"aapcs-vfp\"");
1543  OS << ')';
1544  break;
1545  }
1546  case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break;
1547  case attr::IntelOclBicc: OS << "inteloclbicc"; break;
1548  case attr::PreserveMost:
1549  OS << "preserve_most";
1550  break;
1551 
1552  case attr::PreserveAll:
1553  OS << "preserve_all";
1554  break;
1555  case attr::NoDeref:
1556  OS << "noderef";
1557  break;
1558  }
1559  OS << "))";
1560 }
1561 
1562 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
1563  raw_ostream &OS) {
1564  OS << T->getDecl()->getName();
1565  spaceBeforePlaceHolder(OS);
1566 }
1567 
1568 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
1569  raw_ostream &OS) {}
1570 
1571 void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T,
1572  raw_ostream &OS) {
1573  OS << T->getDecl()->getName();
1574  if (!T->qual_empty()) {
1575  bool isFirst = true;
1576  OS << '<';
1577  for (const auto *I : T->quals()) {
1578  if (isFirst)
1579  isFirst = false;
1580  else
1581  OS << ',';
1582  OS << I->getName();
1583  }
1584  OS << '>';
1585  }
1586 
1587  spaceBeforePlaceHolder(OS);
1588 }
1589 
1590 void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T,
1591  raw_ostream &OS) {}
1592 
1593 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
1594  raw_ostream &OS) {
1595  if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1596  !T->isKindOfTypeAsWritten())
1597  return printBefore(T->getBaseType(), OS);
1598 
1599  if (T->isKindOfTypeAsWritten())
1600  OS << "__kindof ";
1601 
1602  print(T->getBaseType(), OS, StringRef());
1603 
1604  if (T->isSpecializedAsWritten()) {
1605  bool isFirst = true;
1606  OS << '<';
1607  for (auto typeArg : T->getTypeArgsAsWritten()) {
1608  if (isFirst)
1609  isFirst = false;
1610  else
1611  OS << ",";
1612 
1613  print(typeArg, OS, StringRef());
1614  }
1615  OS << '>';
1616  }
1617 
1618  if (!T->qual_empty()) {
1619  bool isFirst = true;
1620  OS << '<';
1621  for (const auto *I : T->quals()) {
1622  if (isFirst)
1623  isFirst = false;
1624  else
1625  OS << ',';
1626  OS << I->getName();
1627  }
1628  OS << '>';
1629  }
1630 
1631  spaceBeforePlaceHolder(OS);
1632 }
1633 
1634 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
1635  raw_ostream &OS) {
1636  if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1637  !T->isKindOfTypeAsWritten())
1638  return printAfter(T->getBaseType(), OS);
1639 }
1640 
1641 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
1642  raw_ostream &OS) {
1643  printBefore(T->getPointeeType(), OS);
1644 
1645  // If we need to print the pointer, print it now.
1646  if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() &&
1647  !T->isObjCClassType() && !T->isObjCQualifiedClassType()) {
1648  if (HasEmptyPlaceHolder)
1649  OS << ' ';
1650  OS << '*';
1651  }
1652 }
1653 
1654 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
1655  raw_ostream &OS) {}
1656 
1657 static
1658 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
1659 
1660 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
1661  return A.getArgument();
1662 }
1663 
1664 static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP,
1665  llvm::raw_ostream &OS) {
1666  A.print(PP, OS);
1667 }
1668 
1669 static void printArgument(const TemplateArgumentLoc &A,
1670  const PrintingPolicy &PP, llvm::raw_ostream &OS) {
1671  const TemplateArgument::ArgKind &Kind = A.getArgument().getKind();
1672  if (Kind == TemplateArgument::ArgKind::Type)
1673  return A.getTypeSourceInfo()->getType().print(OS, PP);
1674  return A.getArgument().print(PP, OS);
1675 }
1676 
1677 template<typename TA>
1678 static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
1679  const PrintingPolicy &Policy, bool SkipBrackets) {
1680  const char *Comma = Policy.MSVCFormatting ? "," : ", ";
1681  if (!SkipBrackets)
1682  OS << '<';
1683 
1684  bool NeedSpace = false;
1685  bool FirstArg = true;
1686  for (const auto &Arg : Args) {
1687  // Print the argument into a string.
1688  SmallString<128> Buf;
1689  llvm::raw_svector_ostream ArgOS(Buf);
1690  const TemplateArgument &Argument = getArgument(Arg);
1691  if (Argument.getKind() == TemplateArgument::Pack) {
1692  if (Argument.pack_size() && !FirstArg)
1693  OS << Comma;
1694  printTo(ArgOS, Argument.getPackAsArray(), Policy, true);
1695  } else {
1696  if (!FirstArg)
1697  OS << Comma;
1698  // Tries to print the argument with location info if exists.
1699  printArgument(Arg, Policy, ArgOS);
1700  }
1701  StringRef ArgString = ArgOS.str();
1702 
1703  // If this is the first argument and its string representation
1704  // begins with the global scope specifier ('::foo'), add a space
1705  // to avoid printing the diagraph '<:'.
1706  if (FirstArg && !ArgString.empty() && ArgString[0] == ':')
1707  OS << ' ';
1708 
1709  OS << ArgString;
1710 
1711  NeedSpace = (!ArgString.empty() && ArgString.back() == '>');
1712  FirstArg = false;
1713  }
1714 
1715  // If the last character of our string is '>', add another space to
1716  // keep the two '>''s separate tokens. We don't *have* to do this in
1717  // C++0x, but it's still good hygiene.
1718  if (NeedSpace)
1719  OS << ' ';
1720 
1721  if (!SkipBrackets)
1722  OS << '>';
1723 }
1724 
1725 void clang::printTemplateArgumentList(raw_ostream &OS,
1726  const TemplateArgumentListInfo &Args,
1727  const PrintingPolicy &Policy) {
1728  return printTo(OS, Args.arguments(), Policy, false);
1729 }
1730 
1731 void clang::printTemplateArgumentList(raw_ostream &OS,
1732  ArrayRef<TemplateArgument> Args,
1733  const PrintingPolicy &Policy) {
1734  printTo(OS, Args, Policy, false);
1735 }
1736 
1737 void clang::printTemplateArgumentList(raw_ostream &OS,
1738  ArrayRef<TemplateArgumentLoc> Args,
1739  const PrintingPolicy &Policy) {
1740  printTo(OS, Args, Policy, false);
1741 }
1742 
1743 std::string Qualifiers::getAsString() const {
1744  LangOptions LO;
1745  return getAsString(PrintingPolicy(LO));
1746 }
1747 
1748 // Appends qualifiers to the given string, separated by spaces. Will
1749 // prefix a space if the string is non-empty. Will not append a final
1750 // space.
1751 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
1752  SmallString<64> Buf;
1753  llvm::raw_svector_ostream StrOS(Buf);
1754  print(StrOS, Policy);
1755  return StrOS.str();
1756 }
1757 
1758 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
1759  if (getCVRQualifiers())
1760  return false;
1761 
1762  if (getAddressSpace() != LangAS::Default)
1763  return false;
1764 
1765  if (getObjCGCAttr())
1766  return false;
1767 
1768  if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
1769  if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
1770  return false;
1771 
1772  return true;
1773 }
1774 
1775 // Appends qualifiers to the given string, separated by spaces. Will
1776 // prefix a space if the string is non-empty. Will not append a final
1777 // space.
1778 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
1779  bool appendSpaceIfNonEmpty) const {
1780  bool addSpace = false;
1781 
1782  unsigned quals = getCVRQualifiers();
1783  if (quals) {
1784  AppendTypeQualList(OS, quals, Policy.Restrict);
1785  addSpace = true;
1786  }
1787  if (hasUnaligned()) {
1788  if (addSpace)
1789  OS << ' ';
1790  OS << "__unaligned";
1791  addSpace = true;
1792  }
1793  LangAS addrspace = getAddressSpace();
1794  if (addrspace != LangAS::Default) {
1795  if (addrspace != LangAS::opencl_private) {
1796  if (addSpace)
1797  OS << ' ';
1798  addSpace = true;
1799  switch (addrspace) {
1800  case LangAS::opencl_global:
1801  OS << "__global";
1802  break;
1803  case LangAS::opencl_local:
1804  OS << "__local";
1805  break;
1806  case LangAS::opencl_private:
1807  break;
1808  case LangAS::opencl_constant:
1809  OS << "__constant";
1810  break;
1811  case LangAS::opencl_generic:
1812  OS << "__generic";
1813  break;
1814  case LangAS::cuda_device:
1815  OS << "__device__";
1816  break;
1817  case LangAS::cuda_constant:
1818  OS << "__constant__";
1819  break;
1820  case LangAS::cuda_shared:
1821  OS << "__shared__";
1822  break;
1823  default:
1824  OS << "__attribute__((address_space(";
1825  OS << toTargetAddressSpace(addrspace);
1826  OS << ")))";
1827  }
1828  }
1829  }
1830  if (Qualifiers::GC gc = getObjCGCAttr()) {
1831  if (addSpace)
1832  OS << ' ';
1833  addSpace = true;
1834  if (gc == Qualifiers::Weak)
1835  OS << "__weak";
1836  else
1837  OS << "__strong";
1838  }
1839  if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
1840  if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
1841  if (addSpace)
1842  OS << ' ';
1843  addSpace = true;
1844  }
1845 
1846  switch (lifetime) {
1847  case Qualifiers::OCL_None: llvm_unreachable("none but true");
1848  case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
1849  case Qualifiers::OCL_Strong:
1850  if (!Policy.SuppressStrongLifetime)
1851  OS << "__strong";
1852  break;
1853 
1854  case Qualifiers::OCL_Weak: OS << "__weak"; break;
1855  case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
1856  }
1857  }
1858 
1859  if (appendSpaceIfNonEmpty && addSpace)
1860  OS << ' ';
1861 }
1862 
1863 std::string QualType::getAsString() const {
1864  return getAsString(split(), LangOptions());
1865 }
1866 
1867 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
1868  std::string S;
1869  getAsStringInternal(S, Policy);
1870  return S;
1871 }
1872 
1873 std::string QualType::getAsString(const Type *ty, Qualifiers qs,
1874  const PrintingPolicy &Policy) {
1875  std::string buffer;
1876  getAsStringInternal(ty, qs, buffer, Policy);
1877  return buffer;
1878 }
1879 
1880 void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy,
1881  const Twine &PlaceHolder, unsigned Indentation) const {
1882  print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder,
1883  Indentation);
1884 }
1885 
1886 void QualType::print(const Type *ty, Qualifiers qs,
1887  raw_ostream &OS, const PrintingPolicy &policy,
1888  const Twine &PlaceHolder, unsigned Indentation) {
1889  SmallString<128> PHBuf;
1890  StringRef PH = PlaceHolder.toStringRef(PHBuf);
1891 
1892  TypePrinter(policy, Indentation).print(ty, qs, OS, PH);
1893 }
1894 
1895 void QualType::getAsStringInternal(std::string &Str,
1896  const PrintingPolicy &Policy) const {
1897  return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str,
1898  Policy);
1899 }
1900 
1901 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
1902  std::string &buffer,
1903  const PrintingPolicy &policy) {
1904  SmallString<256> Buf;
1905  llvm::raw_svector_ostream StrOS(Buf);
1906  TypePrinter(policy).print(ty, qs, StrOS, buffer);
1907  std::string str = StrOS.str();
1908  buffer.swap(str);
1909 }
static StringRef getKeywordName(ElaboratedTypeKeyword Keyword)
Definition: Type.cpp:2690
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:5452
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:4809
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:5205
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:5088
StringRef getName(const PrintingPolicy &Policy) const
Definition: Type.cpp:2764
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:4062
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2585
QualType getElementType() const
Definition: Type.h:6092
QualType getPointeeType() const
Definition: Type.h:2598
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:4160
A (possibly-)qualified type.
Definition: Type.h:643
bool getNoCfCheck() const
Definition: Type.h:3553
__auto_type (GNU extension)
Expr * getUnderlyingExpr() const
Definition: Type.h:4330
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3393
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:557
C Language Family Type Representation.
Defines the SourceManager interface.
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:5288
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5307
const Type * getTypeForDecl() const
Definition: Decl.h:2967
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4041
Defines the C++ template declaration subclasses.
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4823
The base class of the type hierarchy.
Definition: Type.h:1436
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:6059
TemplateTypeParmDecl * getDecl() const
Definition: Type.h:4643
void printExceptionSpecification(raw_ostream &OS, const PrintingPolicy &Policy) const
QualType getElementType() const
Definition: Type.h:2881
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
Definition: Type.h:4879
unsigned getNumParams() const
Definition: Type.h:3927
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6858
Represents a C++17 deduced template specialization type.
Definition: Type.h:4861
bool isCallingConv() const
Definition: Type.cpp:3359
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:37
void print(llvm::raw_ostream &OS, const Pointer &P, ASTContext &Ctx, QualType Ty)
Definition: InterpFrame.cpp:62
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4677
The collection of all-type qualifiers we support.
Definition: Type.h:137
bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType)
PipeType - OpenCL20.
Definition: Type.h:6078
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:3556
void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const
QualType getPointeeType() const
Definition: Type.h:2702
is ARM Neon vector
Definition: Type.h:3222
bool isObjCIdType() const
Definition: Type.h:6524
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4980
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
const IdentifierInfo * getMacroIdentifier() const
Definition: Type.h:4234
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4733
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:5255
bool isObjCQualifiedClassType() const
Definition: Type.h:6518
QualType getModifiedType() const
Return this attributed type&#39;s modified type with no qualifiers attached to it.
Definition: Type.cpp:3200
unsigned SuppressStrongLifetime
When true, suppress printing of the __strong lifetime qualifier in ARC.
bool getProducesResult() const
Definition: Type.h:3551
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:2786
UnresolvedUsingTypenameDecl * getDecl() const
Definition: Type.h:4171
bool isMSTypeSpec() const
Definition: Type.cpp:3346
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1392
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:4216
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4250
const Type * getClass() const
Definition: Type.h:2838
Expr * getSizeExpr() const
Definition: Type.h:3029
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6148
bool getNoReturn() const
Definition: Type.h:3550
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:3225
Expr * getSizeExpr() const
Definition: Type.h:3086
bool getNoCallerSavedRegs() const
Definition: Type.h:3552
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2740
Expr * getSizeExpr() const
Definition: Type.h:3296
QualType getElementType() const
Definition: Type.h:3182
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:3166
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:3688
Expr * getAddrSpaceExpr() const
Definition: Type.h:3137
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:3725
qual_range quals() const
Definition: Type.h:5514
static SplitQualType splitAccordingToPolicy(QualType QT, const PrintingPolicy &Policy)
ObjCTypeParamDecl * getDecl() const
Definition: Type.h:5583
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3064
bool isValid() const
QualType getElementType() const
Definition: Type.h:2538
unsigned SuppressTagKeyword
Whether type printing should skip printing the tag keyword.
Definition: PrettyPrinter.h:92
IdentifierInfo * getIdentifier() const
Definition: Type.cpp:3387
Defines the clang::LangOptions interface.
StringRef getKindName() const
Definition: Decl.h:3308
int Id
Definition: ASTDiff.cpp:190
unsigned getIndex() const
Definition: Type.h:4640
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6923
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:6530
DeclContext * getDeclContext()
Definition: DeclBase.h:438
QualType getBaseType() const
Definition: Type.h:4389
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
Definition: Type.h:5314
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:278
Represents the type decltype(expr) (C++11).
Definition: Type.h:4320
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:1831
A unary type transform, which is a type constructed from another.
Definition: Type.h:4363
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:2596
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1779
Represents an unpacked "presumed" location which can be presented to the user.
Represents a GCC generic vector type.
Definition: Type.h:3206
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2883
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2768
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:4391
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:4259
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition: Type.h:4052
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:6156
RecordDecl * getDecl() const
Definition: Type.h:4454
const char * getFilename() const
Return the presumed filename of this location.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
is AltiVec &#39;vector Pixel&#39;
Definition: Type.h:3216
QualType getCanonicalType() const
Definition: Type.h:6187
not a target-specific vector type
Definition: Type.h:3210
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:4117
ElaboratedTypeKeyword getKeyword() const
Definition: Type.h:5166
unsigned getColumn() const
Return the presumed column number of this location.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5827
Sugar for parentheses used when specifying types.
Definition: Type.h:2555
QualType getAdjustedType() const
Definition: Type.h:2650
QualType getReturnType() const
Definition: Type.h:3651
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4470
Represents typeof(type), a GCC extension.
Definition: Type.h:4293
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5814
unsigned SuppressScope
Suppresses printing of scope specifiers.
ParameterABI getABI() const
Return the ABI treatment of this parameter.
Definition: Type.h:3432
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3133
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:377
CallingConv getCC() const
Definition: Type.h:3563
QualType getElementType() const
Definition: Type.h:3241
Represents a vector type where either the type or size is dependent.
Definition: Type.h:3283
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1389
Qualifiers getMethodQuals() const
Definition: Type.h:4054
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4751
QualType getEquivalentType() const
Definition: Type.h:4525
QualType getInnerType() const
Definition: Type.h:2568
is AltiVec &#39;vector bool ...&#39;
Definition: Type.h:3219
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5242
is AltiVec vector
Definition: Type.h:3213
AutoTypeKeyword getKeyword() const
Definition: Type.h:4838
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2887
TypeClass getTypeClass() const
Definition: Type.h:1851
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:5381
EnumDecl * getDecl() const
Definition: Type.h:4477
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1395
ParameterABI
Kinds of parameter ABI.
Definition: Specifiers.h:338
std::string getAsString() const
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2670
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:5054
QualType getPointeeType() const
Definition: Type.h:3138
Represents a pack expansion of types.
Definition: Type.h:5431
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:2985
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2633
Dataflow Directional Tag Classes.
ExtInfo getExtInfo() const
Definition: Type.h:3662
NestedNameSpecifier * getQualifier() const
Definition: Type.h:5366
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:3251
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:2804
QualType getModifiedType() const
Definition: Type.h:4524
Pointer to a block type.
Definition: Type.h:2687
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4444
Complex values, per C99 6.2.5p11.
Definition: Type.h:2525
unsigned getIndexTypeCVRQualifiers() const
Definition: Type.h:2891
bool empty() const
Definition: Type.h:415
const llvm::APInt & getSize() const
Definition: Type.h:2929
Kind getAttrKind() const
Definition: Type.h:4520
bool isFunctionType() const
Definition: Type.h:6387
bool isObjCQualifiedIdType() const
Definition: Type.h:6512
ExtVectorType - Extended vector type.
Definition: Type.h:3325
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2721
bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const
QualType getUnderlyingType() const
Definition: Type.h:4308
SourceManager & getSourceManager()
Definition: ASTContext.h:678
A template argument list.
Definition: DeclTemplate.h:224
VectorType::VectorKind getVectorKind() const
Definition: Type.h:3299
TypedefNameDecl * getDecl() const
Definition: Type.h:4206
unsigned getDepth() const
Definition: Type.h:4639
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4499
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:3929
Represents a type parameter type in Objective C.
Definition: Type.h:5540
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:3343
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5340
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:4996
Represents a C array with an unspecified size.
Definition: Type.h:2966
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6175
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Definition: Type.h:5245
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4698
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2436
static QualType skipTopLevelReferences(QualType T)
bool qual_empty() const
Definition: Type.h:5518
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:275
unsigned getNumElements() const
Definition: Type.h:3242
bool isReadOnly() const
Definition: Type.h:6111
Microsoft __declspec(nothrow) extension.
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:3124
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4917
This represents a decl that may have a name.
Definition: Decl.h:248
bool isTranslationUnit() const
Definition: DeclBase.h:1854
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3010
No keyword precedes the qualified type name.
Definition: Type.h:5147
QualType getElementType() const
Definition: Type.h:3297
llvm::Optional< NullabilityKind > getImmediateNullability() const
Definition: Type.cpp:3955
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2906
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3504
SourceLocation getLocation() const
Definition: DeclBase.h:429
QualType getPointeeType() const
Definition: Type.h:2824
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
This parameter (which must have pointer type) is a Swift indirect result parameter.
const IdentifierInfo * getIdentifier() const
Definition: Type.h:5367