1 //===--- TypePrinter.cpp - Pretty-Print Clang Types -----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code to print types from Clang's type system.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/PrettyPrinter.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Decl.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/Type.h"
21 #include "clang/Basic/LangOptions.h"
22 #include "clang/Basic/SourceManager.h"
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/Support/SaveAndRestore.h"
26 #include "llvm/Support/raw_ostream.h"
27 using namespace clang;
30 /// \brief RAII object that enables printing of the ARC __strong lifetime
32 class IncludeStrongLifetimeRAII {
33 PrintingPolicy &Policy;
37 explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy)
38 : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
39 if (!Policy.SuppressLifetimeQualifiers)
40 Policy.SuppressStrongLifetime = false;
43 ~IncludeStrongLifetimeRAII() {
44 Policy.SuppressStrongLifetime = Old;
48 class ParamPolicyRAII {
49 PrintingPolicy &Policy;
53 explicit ParamPolicyRAII(PrintingPolicy &Policy)
54 : Policy(Policy), Old(Policy.SuppressSpecifiers) {
55 Policy.SuppressSpecifiers = false;
59 Policy.SuppressSpecifiers = Old;
63 class ElaboratedTypePolicyRAII {
64 PrintingPolicy &Policy;
65 bool SuppressTagKeyword;
69 explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) {
70 SuppressTagKeyword = Policy.SuppressTagKeyword;
71 SuppressScope = Policy.SuppressScope;
72 Policy.SuppressTagKeyword = true;
73 Policy.SuppressScope = true;
76 ~ElaboratedTypePolicyRAII() {
77 Policy.SuppressTagKeyword = SuppressTagKeyword;
78 Policy.SuppressScope = SuppressScope;
83 PrintingPolicy Policy;
84 bool HasEmptyPlaceHolder;
85 bool InsideCCAttribute;
88 explicit TypePrinter(const PrintingPolicy &Policy)
89 : Policy(Policy), HasEmptyPlaceHolder(false), InsideCCAttribute(false) { }
91 void print(const Type *ty, Qualifiers qs, raw_ostream &OS,
92 StringRef PlaceHolder);
93 void print(QualType T, raw_ostream &OS, StringRef PlaceHolder);
95 static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier);
96 void spaceBeforePlaceHolder(raw_ostream &OS);
97 void printTypeSpec(const NamedDecl *D, raw_ostream &OS);
99 void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS);
100 void printBefore(QualType T, raw_ostream &OS);
101 void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS);
102 void printAfter(QualType T, raw_ostream &OS);
103 void AppendScope(DeclContext *DC, raw_ostream &OS);
104 void printTag(TagDecl *T, raw_ostream &OS);
105 #define ABSTRACT_TYPE(CLASS, PARENT)
106 #define TYPE(CLASS, PARENT) \
107 void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \
108 void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS);
109 #include "clang/AST/TypeNodes.def"
113 static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals, bool C99) {
114 bool appendSpace = false;
115 if (TypeQuals & Qualifiers::Const) {
119 if (TypeQuals & Qualifiers::Volatile) {
120 if (appendSpace) OS << ' ';
124 if (TypeQuals & Qualifiers::Restrict) {
125 if (appendSpace) OS << ' ';
134 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) {
135 if (!HasEmptyPlaceHolder)
139 void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) {
140 SplitQualType split = t.split();
141 print(split.Ty, split.Quals, OS, PlaceHolder);
144 void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
145 StringRef PlaceHolder) {
151 SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty());
153 printBefore(T, Quals, OS);
155 printAfter(T, Quals, OS);
158 bool TypePrinter::canPrefixQualifiers(const Type *T,
159 bool &NeedARCStrongQualifier) {
160 // CanPrefixQualifiers - We prefer to print type qualifiers before the type,
161 // so that we get "const int" instead of "int const", but we can't do this if
162 // the type is complex. For example if the type is "int*", we *must* print
163 // "int * const", printing "const int *" is different. Only do this when the
164 // type expands to a simple string.
165 bool CanPrefixQualifiers = false;
166 NeedARCStrongQualifier = false;
167 Type::TypeClass TC = T->getTypeClass();
168 if (const AutoType *AT = dyn_cast<AutoType>(T))
169 TC = AT->desugar()->getTypeClass();
170 if (const SubstTemplateTypeParmType *Subst
171 = dyn_cast<SubstTemplateTypeParmType>(T))
172 TC = Subst->getReplacementType()->getTypeClass();
178 case Type::UnresolvedUsing:
180 case Type::TypeOfExpr:
183 case Type::UnaryTransform:
186 case Type::Elaborated:
187 case Type::TemplateTypeParm:
188 case Type::SubstTemplateTypeParmPack:
189 case Type::TemplateSpecialization:
190 case Type::InjectedClassName:
191 case Type::DependentName:
192 case Type::DependentTemplateSpecialization:
193 case Type::ObjCObject:
194 case Type::ObjCInterface:
196 CanPrefixQualifiers = true;
199 case Type::ObjCObjectPointer:
200 CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
201 T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType();
204 case Type::ConstantArray:
205 case Type::IncompleteArray:
206 case Type::VariableArray:
207 case Type::DependentSizedArray:
208 NeedARCStrongQualifier = true;
214 case Type::BlockPointer:
215 case Type::LValueReference:
216 case Type::RValueReference:
217 case Type::MemberPointer:
218 case Type::DependentSizedExtVector:
220 case Type::ExtVector:
221 case Type::FunctionProto:
222 case Type::FunctionNoProto:
224 case Type::Attributed:
225 case Type::PackExpansion:
226 case Type::SubstTemplateTypeParm:
227 CanPrefixQualifiers = false;
231 return CanPrefixQualifiers;
234 void TypePrinter::printBefore(QualType T, raw_ostream &OS) {
235 SplitQualType Split = T.split();
237 // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2
239 Qualifiers Quals = Split.Quals;
240 if (const SubstTemplateTypeParmType *Subst =
241 dyn_cast<SubstTemplateTypeParmType>(Split.Ty))
242 Quals -= QualType(Subst, 0).getQualifiers();
244 printBefore(Split.Ty, Quals, OS);
247 /// \brief Prints the part of the type string before an identifier, e.g. for
248 /// "int foo[10]" it prints "int ".
249 void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) {
250 if (Policy.SuppressSpecifiers && T->isSpecifierType())
253 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder);
255 // Print qualifiers as appropriate.
257 bool CanPrefixQualifiers = false;
258 bool NeedARCStrongQualifier = false;
259 CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier);
261 if (CanPrefixQualifiers && !Quals.empty()) {
262 if (NeedARCStrongQualifier) {
263 IncludeStrongLifetimeRAII Strong(Policy);
264 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
266 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
270 bool hasAfterQuals = false;
271 if (!CanPrefixQualifiers && !Quals.empty()) {
272 hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy);
274 HasEmptyPlaceHolder = false;
277 switch (T->getTypeClass()) {
278 #define ABSTRACT_TYPE(CLASS, PARENT)
279 #define TYPE(CLASS, PARENT) case Type::CLASS: \
280 print##CLASS##Before(cast<CLASS##Type>(T), OS); \
282 #include "clang/AST/TypeNodes.def"
286 if (NeedARCStrongQualifier) {
287 IncludeStrongLifetimeRAII Strong(Policy);
288 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
290 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
295 void TypePrinter::printAfter(QualType t, raw_ostream &OS) {
296 SplitQualType split = t.split();
297 printAfter(split.Ty, split.Quals, OS);
300 /// \brief Prints the part of the type string after an identifier, e.g. for
301 /// "int foo[10]" it prints "[10]".
302 void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) {
303 switch (T->getTypeClass()) {
304 #define ABSTRACT_TYPE(CLASS, PARENT)
305 #define TYPE(CLASS, PARENT) case Type::CLASS: \
306 print##CLASS##After(cast<CLASS##Type>(T), OS); \
308 #include "clang/AST/TypeNodes.def"
312 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) {
313 OS << T->getName(Policy);
314 spaceBeforePlaceHolder(OS);
316 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) { }
318 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) {
320 printBefore(T->getElementType(), OS);
322 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) {
323 printAfter(T->getElementType(), OS);
326 void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) {
327 IncludeStrongLifetimeRAII Strong(Policy);
328 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
329 printBefore(T->getPointeeType(), OS);
330 // Handle things like 'int (*A)[4];' correctly.
331 // FIXME: this should include vectors, but vectors use attributes I guess.
332 if (isa<ArrayType>(T->getPointeeType()))
336 void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) {
337 IncludeStrongLifetimeRAII Strong(Policy);
338 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
339 // Handle things like 'int (*A)[4];' correctly.
340 // FIXME: this should include vectors, but vectors use attributes I guess.
341 if (isa<ArrayType>(T->getPointeeType()))
343 printAfter(T->getPointeeType(), OS);
346 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T,
348 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
349 printBefore(T->getPointeeType(), OS);
352 void TypePrinter::printBlockPointerAfter(const BlockPointerType *T,
354 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
355 printAfter(T->getPointeeType(), OS);
358 void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T,
360 IncludeStrongLifetimeRAII Strong(Policy);
361 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
362 printBefore(T->getPointeeTypeAsWritten(), OS);
363 // Handle things like 'int (&A)[4];' correctly.
364 // FIXME: this should include vectors, but vectors use attributes I guess.
365 if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
369 void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T,
371 IncludeStrongLifetimeRAII Strong(Policy);
372 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
373 // Handle things like 'int (&A)[4];' correctly.
374 // FIXME: this should include vectors, but vectors use attributes I guess.
375 if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
377 printAfter(T->getPointeeTypeAsWritten(), OS);
380 void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T,
382 IncludeStrongLifetimeRAII Strong(Policy);
383 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
384 printBefore(T->getPointeeTypeAsWritten(), OS);
385 // Handle things like 'int (&&A)[4];' correctly.
386 // FIXME: this should include vectors, but vectors use attributes I guess.
387 if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
391 void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T,
393 IncludeStrongLifetimeRAII Strong(Policy);
394 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
395 // Handle things like 'int (&&A)[4];' correctly.
396 // FIXME: this should include vectors, but vectors use attributes I guess.
397 if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
399 printAfter(T->getPointeeTypeAsWritten(), OS);
402 void TypePrinter::printMemberPointerBefore(const MemberPointerType *T,
404 IncludeStrongLifetimeRAII Strong(Policy);
405 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
406 printBefore(T->getPointeeType(), OS);
407 // Handle things like 'int (Cls::*A)[4];' correctly.
408 // FIXME: this should include vectors, but vectors use attributes I guess.
409 if (isa<ArrayType>(T->getPointeeType()))
412 PrintingPolicy InnerPolicy(Policy);
413 InnerPolicy.SuppressTag = false;
414 TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef());
418 void TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
420 IncludeStrongLifetimeRAII Strong(Policy);
421 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
422 // Handle things like 'int (Cls::*A)[4];' correctly.
423 // FIXME: this should include vectors, but vectors use attributes I guess.
424 if (isa<ArrayType>(T->getPointeeType()))
426 printAfter(T->getPointeeType(), OS);
429 void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T,
431 IncludeStrongLifetimeRAII Strong(Policy);
432 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
433 printBefore(T->getElementType(), OS);
435 void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
438 if (T->getIndexTypeQualifiers().hasQualifiers()) {
439 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.LangOpts.C99);
443 if (T->getSizeModifier() == ArrayType::Static)
446 OS << T->getSize().getZExtValue() << ']';
447 printAfter(T->getElementType(), OS);
450 void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T,
452 IncludeStrongLifetimeRAII Strong(Policy);
453 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
454 printBefore(T->getElementType(), OS);
456 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
459 printAfter(T->getElementType(), OS);
462 void TypePrinter::printVariableArrayBefore(const VariableArrayType *T,
464 IncludeStrongLifetimeRAII Strong(Policy);
465 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
466 printBefore(T->getElementType(), OS);
468 void TypePrinter::printVariableArrayAfter(const VariableArrayType *T,
471 if (T->getIndexTypeQualifiers().hasQualifiers()) {
472 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.LangOpts.C99);
476 if (T->getSizeModifier() == VariableArrayType::Static)
478 else if (T->getSizeModifier() == VariableArrayType::Star)
481 if (T->getSizeExpr())
482 T->getSizeExpr()->printPretty(OS, nullptr, Policy);
485 printAfter(T->getElementType(), OS);
488 void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) {
489 // Print the adjusted representation, otherwise the adjustment will be
491 printBefore(T->getAdjustedType(), OS);
493 void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) {
494 printAfter(T->getAdjustedType(), OS);
497 void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) {
498 // Print as though it's a pointer.
499 printAdjustedBefore(T, OS);
501 void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) {
502 printAdjustedAfter(T, OS);
505 void TypePrinter::printDependentSizedArrayBefore(
506 const DependentSizedArrayType *T,
508 IncludeStrongLifetimeRAII Strong(Policy);
509 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
510 printBefore(T->getElementType(), OS);
512 void TypePrinter::printDependentSizedArrayAfter(
513 const DependentSizedArrayType *T,
516 if (T->getSizeExpr())
517 T->getSizeExpr()->printPretty(OS, nullptr, Policy);
519 printAfter(T->getElementType(), OS);
522 void TypePrinter::printDependentSizedExtVectorBefore(
523 const DependentSizedExtVectorType *T,
525 printBefore(T->getElementType(), OS);
527 void TypePrinter::printDependentSizedExtVectorAfter(
528 const DependentSizedExtVectorType *T,
530 OS << " __attribute__((ext_vector_type(";
531 if (T->getSizeExpr())
532 T->getSizeExpr()->printPretty(OS, nullptr, Policy);
534 printAfter(T->getElementType(), OS);
537 void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) {
538 switch (T->getVectorKind()) {
539 case VectorType::AltiVecPixel:
540 OS << "__vector __pixel ";
542 case VectorType::AltiVecBool:
543 OS << "__vector __bool ";
544 printBefore(T->getElementType(), OS);
546 case VectorType::AltiVecVector:
548 printBefore(T->getElementType(), OS);
550 case VectorType::NeonVector:
551 OS << "__attribute__((neon_vector_type("
552 << T->getNumElements() << "))) ";
553 printBefore(T->getElementType(), OS);
555 case VectorType::NeonPolyVector:
556 OS << "__attribute__((neon_polyvector_type(" <<
557 T->getNumElements() << "))) ";
558 printBefore(T->getElementType(), OS);
560 case VectorType::GenericVector: {
561 // FIXME: We prefer to print the size directly here, but have no way
562 // to get the size of the type.
563 OS << "__attribute__((__vector_size__("
564 << T->getNumElements()
566 print(T->getElementType(), OS, StringRef());
568 printBefore(T->getElementType(), OS);
573 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) {
574 printAfter(T->getElementType(), OS);
577 void TypePrinter::printExtVectorBefore(const ExtVectorType *T,
579 printBefore(T->getElementType(), OS);
581 void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) {
582 printAfter(T->getElementType(), OS);
583 OS << " __attribute__((ext_vector_type(";
584 OS << T->getNumElements();
589 FunctionProtoType::printExceptionSpecification(raw_ostream &OS,
590 const PrintingPolicy &Policy)
593 if (hasDynamicExceptionSpec()) {
595 if (getExceptionSpecType() == EST_MSAny)
598 for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) {
602 OS << getExceptionType(I).stream(Policy);
605 } else if (isNoexceptExceptionSpec(getExceptionSpecType())) {
607 if (getExceptionSpecType() == EST_ComputedNoexcept) {
609 if (getNoexceptExpr())
610 getNoexceptExpr()->printPretty(OS, nullptr, Policy);
616 void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T,
618 if (T->hasTrailingReturn()) {
620 if (!HasEmptyPlaceHolder)
623 // If needed for precedence reasons, wrap the inner part in grouping parens.
624 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
625 printBefore(T->getReturnType(), OS);
626 if (!PrevPHIsEmpty.get())
631 void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
633 // If needed for precedence reasons, wrap the inner part in grouping parens.
634 if (!HasEmptyPlaceHolder)
636 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
640 ParamPolicyRAII ParamPolicy(Policy);
641 for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) {
643 print(T->getParamType(i), OS, StringRef());
647 if (T->isVariadic()) {
648 if (T->getNumParams())
651 } else if (T->getNumParams() == 0 && !Policy.LangOpts.CPlusPlus) {
652 // Do not emit int() if we have a proto, emit 'int(void)'.
658 FunctionType::ExtInfo Info = T->getExtInfo();
660 if (!InsideCCAttribute) {
661 switch (Info.getCC()) {
663 // The C calling convention is the default on the vast majority of platforms
664 // we support. If the user wrote it explicitly, it will usually be printed
665 // while traversing the AttributedType. If the type has been desugared, let
666 // the canonical spelling be the implicit calling convention.
667 // FIXME: It would be better to be explicit in certain contexts, such as a
668 // cdecl function typedef used to declare a member function with the
669 // Microsoft C++ ABI.
672 OS << " __attribute__((stdcall))";
675 OS << " __attribute__((fastcall))";
678 OS << " __attribute__((thiscall))";
680 case CC_X86VectorCall:
681 OS << " __attribute__((vectorcall))";
684 OS << " __attribute__((pascal))";
687 OS << " __attribute__((pcs(\"aapcs\")))";
690 OS << " __attribute__((pcs(\"aapcs-vfp\")))";
692 case CC_IntelOclBicc:
693 OS << " __attribute__((intel_ocl_bicc))";
696 OS << " __attribute__((ms_abi))";
699 OS << " __attribute__((sysv_abi))";
701 case CC_SpirFunction:
703 // Do nothing. These CCs are not available as attributes.
708 if (Info.getNoReturn())
709 OS << " __attribute__((noreturn))";
710 if (Info.getRegParm())
711 OS << " __attribute__((regparm ("
712 << Info.getRegParm() << ")))";
714 if (unsigned quals = T->getTypeQuals()) {
716 AppendTypeQualList(OS, quals, Policy.LangOpts.C99);
719 switch (T->getRefQualifier()) {
731 T->printExceptionSpecification(OS, Policy);
733 if (T->hasTrailingReturn()) {
735 print(T->getReturnType(), OS, StringRef());
737 printAfter(T->getReturnType(), OS);
740 void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T,
742 // If needed for precedence reasons, wrap the inner part in grouping parens.
743 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
744 printBefore(T->getReturnType(), OS);
745 if (!PrevPHIsEmpty.get())
748 void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T,
750 // If needed for precedence reasons, wrap the inner part in grouping parens.
751 if (!HasEmptyPlaceHolder)
753 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
756 if (T->getNoReturnAttr())
757 OS << " __attribute__((noreturn))";
758 printAfter(T->getReturnType(), OS);
761 void TypePrinter::printTypeSpec(const NamedDecl *D, raw_ostream &OS) {
762 IdentifierInfo *II = D->getIdentifier();
764 spaceBeforePlaceHolder(OS);
767 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
769 printTypeSpec(T->getDecl(), OS);
771 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
774 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
775 printTypeSpec(T->getDecl(), OS);
777 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) { }
779 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
782 if (T->getUnderlyingExpr())
783 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
784 spaceBeforePlaceHolder(OS);
786 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
789 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
791 print(T->getUnderlyingType(), OS, StringRef());
793 spaceBeforePlaceHolder(OS);
795 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) { }
797 void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
799 if (T->getUnderlyingExpr())
800 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
802 spaceBeforePlaceHolder(OS);
804 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) { }
806 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
808 IncludeStrongLifetimeRAII Strong(Policy);
810 switch (T->getUTTKind()) {
811 case UnaryTransformType::EnumUnderlyingType:
812 OS << "__underlying_type(";
813 print(T->getBaseType(), OS, StringRef());
815 spaceBeforePlaceHolder(OS);
819 printBefore(T->getBaseType(), OS);
821 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
823 IncludeStrongLifetimeRAII Strong(Policy);
825 switch (T->getUTTKind()) {
826 case UnaryTransformType::EnumUnderlyingType:
830 printAfter(T->getBaseType(), OS);
833 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
834 // If the type has been deduced, do not print 'auto'.
835 if (!T->getDeducedType().isNull()) {
836 printBefore(T->getDeducedType(), OS);
838 OS << (T->isDecltypeAuto() ? "decltype(auto)" : "auto");
839 spaceBeforePlaceHolder(OS);
842 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
843 // If the type has been deduced, do not print 'auto'.
844 if (!T->getDeducedType().isNull())
845 printAfter(T->getDeducedType(), OS);
848 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) {
849 IncludeStrongLifetimeRAII Strong(Policy);
852 print(T->getValueType(), OS, StringRef());
854 spaceBeforePlaceHolder(OS);
856 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) { }
858 /// Appends the given scope to the end of a string.
859 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) {
860 if (DC->isTranslationUnit()) return;
861 if (DC->isFunctionOrMethod()) return;
862 AppendScope(DC->getParent(), OS);
864 if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DC)) {
865 if (Policy.SuppressUnwrittenScope &&
866 (NS->isAnonymousNamespace() || NS->isInline()))
868 if (NS->getIdentifier())
869 OS << NS->getName() << "::";
871 OS << "(anonymous namespace)::";
872 } else if (ClassTemplateSpecializationDecl *Spec
873 = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
874 IncludeStrongLifetimeRAII Strong(Policy);
875 OS << Spec->getIdentifier()->getName();
876 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
877 TemplateSpecializationType::PrintTemplateArgumentList(OS,
882 } else if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) {
883 if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
884 OS << Typedef->getIdentifier()->getName() << "::";
885 else if (Tag->getIdentifier())
886 OS << Tag->getIdentifier()->getName() << "::";
892 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
893 if (Policy.SuppressTag)
896 bool HasKindDecoration = false;
898 // bool SuppressTagKeyword
899 // = Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword;
901 // We don't print tags unless this is an elaborated type.
902 // In C, we just assume every RecordType is an elaborated type.
903 if (!(Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword ||
904 D->getTypedefNameForAnonDecl())) {
905 HasKindDecoration = true;
906 OS << D->getKindName();
910 // Compute the full nested-name-specifier for this type.
911 // In C, this will always be empty except when the type
912 // being printed is anonymous within other Record.
913 if (!Policy.SuppressScope)
914 AppendScope(D->getDeclContext(), OS);
916 if (const IdentifierInfo *II = D->getIdentifier())
918 else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
919 assert(Typedef->getIdentifier() && "Typedef without identifier?");
920 OS << Typedef->getIdentifier()->getName();
922 // Make an unambiguous representation for anonymous types, e.g.
923 // (anonymous enum at /usr/include/string.h:120:9)
925 if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) {
927 HasKindDecoration = true;
932 if (Policy.AnonymousTagLocations) {
933 // Suppress the redundant tag keyword if we just printed one.
934 // We don't have to worry about ElaboratedTypes here because you can't
935 // refer to an anonymous type with one.
936 if (!HasKindDecoration)
937 OS << " " << D->getKindName();
939 PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc(
941 if (PLoc.isValid()) {
942 OS << " at " << PLoc.getFilename()
943 << ':' << PLoc.getLine()
944 << ':' << PLoc.getColumn();
951 // If this is a class template specialization, print the template
953 if (ClassTemplateSpecializationDecl *Spec
954 = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
955 const TemplateArgument *Args;
957 if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
958 const TemplateSpecializationType *TST =
959 cast<TemplateSpecializationType>(TAW->getType());
960 Args = TST->getArgs();
961 NumArgs = TST->getNumArgs();
963 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
964 Args = TemplateArgs.data();
965 NumArgs = TemplateArgs.size();
967 IncludeStrongLifetimeRAII Strong(Policy);
968 TemplateSpecializationType::PrintTemplateArgumentList(OS,
973 spaceBeforePlaceHolder(OS);
976 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
977 printTag(T->getDecl(), OS);
979 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) { }
981 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
982 printTag(T->getDecl(), OS);
984 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) { }
986 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
988 if (IdentifierInfo *Id = T->getIdentifier())
991 OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
992 spaceBeforePlaceHolder(OS);
994 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
997 void TypePrinter::printSubstTemplateTypeParmBefore(
998 const SubstTemplateTypeParmType *T,
1000 IncludeStrongLifetimeRAII Strong(Policy);
1001 printBefore(T->getReplacementType(), OS);
1003 void TypePrinter::printSubstTemplateTypeParmAfter(
1004 const SubstTemplateTypeParmType *T,
1006 IncludeStrongLifetimeRAII Strong(Policy);
1007 printAfter(T->getReplacementType(), OS);
1010 void TypePrinter::printSubstTemplateTypeParmPackBefore(
1011 const SubstTemplateTypeParmPackType *T,
1013 IncludeStrongLifetimeRAII Strong(Policy);
1014 printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1016 void TypePrinter::printSubstTemplateTypeParmPackAfter(
1017 const SubstTemplateTypeParmPackType *T,
1019 IncludeStrongLifetimeRAII Strong(Policy);
1020 printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1023 void TypePrinter::printTemplateSpecializationBefore(
1024 const TemplateSpecializationType *T,
1026 IncludeStrongLifetimeRAII Strong(Policy);
1027 T->getTemplateName().print(OS, Policy);
1029 TemplateSpecializationType::PrintTemplateArgumentList(OS,
1033 spaceBeforePlaceHolder(OS);
1035 void TypePrinter::printTemplateSpecializationAfter(
1036 const TemplateSpecializationType *T,
1037 raw_ostream &OS) { }
1039 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
1041 printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1043 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
1044 raw_ostream &OS) { }
1046 void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
1048 if (Policy.SuppressTag && isa<TagType>(T->getNamedType()))
1050 OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1051 if (T->getKeyword() != ETK_None)
1053 NestedNameSpecifier* Qualifier = T->getQualifier();
1055 Qualifier->print(OS, Policy);
1057 ElaboratedTypePolicyRAII PolicyRAII(Policy);
1058 printBefore(T->getNamedType(), OS);
1060 void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
1062 ElaboratedTypePolicyRAII PolicyRAII(Policy);
1063 printAfter(T->getNamedType(), OS);
1066 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
1067 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1068 printBefore(T->getInnerType(), OS);
1071 printBefore(T->getInnerType(), OS);
1073 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
1074 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1076 printAfter(T->getInnerType(), OS);
1078 printAfter(T->getInnerType(), OS);
1081 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
1083 OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1084 if (T->getKeyword() != ETK_None)
1087 T->getQualifier()->print(OS, Policy);
1089 OS << T->getIdentifier()->getName();
1090 spaceBeforePlaceHolder(OS);
1092 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
1093 raw_ostream &OS) { }
1095 void TypePrinter::printDependentTemplateSpecializationBefore(
1096 const DependentTemplateSpecializationType *T, raw_ostream &OS) {
1097 IncludeStrongLifetimeRAII Strong(Policy);
1099 OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1100 if (T->getKeyword() != ETK_None)
1103 if (T->getQualifier())
1104 T->getQualifier()->print(OS, Policy);
1105 OS << T->getIdentifier()->getName();
1106 TemplateSpecializationType::PrintTemplateArgumentList(OS,
1110 spaceBeforePlaceHolder(OS);
1112 void TypePrinter::printDependentTemplateSpecializationAfter(
1113 const DependentTemplateSpecializationType *T, raw_ostream &OS) { }
1115 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
1117 printBefore(T->getPattern(), OS);
1119 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
1121 printAfter(T->getPattern(), OS);
1125 void TypePrinter::printAttributedBefore(const AttributedType *T,
1127 // Prefer the macro forms of the GC and ownership qualifiers.
1128 if (T->getAttrKind() == AttributedType::attr_objc_gc ||
1129 T->getAttrKind() == AttributedType::attr_objc_ownership)
1130 return printBefore(T->getEquivalentType(), OS);
1132 if (T->getAttrKind() == AttributedType::attr_objc_kindof)
1135 printBefore(T->getModifiedType(), OS);
1137 if (T->isMSTypeSpec()) {
1138 switch (T->getAttrKind()) {
1140 case AttributedType::attr_ptr32: OS << " __ptr32"; break;
1141 case AttributedType::attr_ptr64: OS << " __ptr64"; break;
1142 case AttributedType::attr_sptr: OS << " __sptr"; break;
1143 case AttributedType::attr_uptr: OS << " __uptr"; break;
1145 spaceBeforePlaceHolder(OS);
1148 // Print nullability type specifiers.
1149 if (T->getAttrKind() == AttributedType::attr_nonnull ||
1150 T->getAttrKind() == AttributedType::attr_nullable ||
1151 T->getAttrKind() == AttributedType::attr_null_unspecified) {
1152 if (T->getAttrKind() == AttributedType::attr_nonnull)
1154 else if (T->getAttrKind() == AttributedType::attr_nullable)
1156 else if (T->getAttrKind() == AttributedType::attr_null_unspecified)
1157 OS << " _Null_unspecified";
1159 llvm_unreachable("unhandled nullability");
1160 spaceBeforePlaceHolder(OS);
1164 void TypePrinter::printAttributedAfter(const AttributedType *T,
1166 // Prefer the macro forms of the GC and ownership qualifiers.
1167 if (T->getAttrKind() == AttributedType::attr_objc_gc ||
1168 T->getAttrKind() == AttributedType::attr_objc_ownership)
1169 return printAfter(T->getEquivalentType(), OS);
1171 if (T->getAttrKind() == AttributedType::attr_objc_kindof)
1174 // TODO: not all attributes are GCC-style attributes.
1175 if (T->isMSTypeSpec())
1178 // Nothing to print after.
1179 if (T->getAttrKind() == AttributedType::attr_nonnull ||
1180 T->getAttrKind() == AttributedType::attr_nullable ||
1181 T->getAttrKind() == AttributedType::attr_null_unspecified)
1182 return printAfter(T->getModifiedType(), OS);
1184 // If this is a calling convention attribute, don't print the implicit CC from
1185 // the modified type.
1186 SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv());
1188 printAfter(T->getModifiedType(), OS);
1190 // Print nullability type specifiers that occur after
1191 if (T->getAttrKind() == AttributedType::attr_nonnull ||
1192 T->getAttrKind() == AttributedType::attr_nullable ||
1193 T->getAttrKind() == AttributedType::attr_null_unspecified) {
1194 if (T->getAttrKind() == AttributedType::attr_nonnull)
1196 else if (T->getAttrKind() == AttributedType::attr_nullable)
1198 else if (T->getAttrKind() == AttributedType::attr_null_unspecified)
1199 OS << " _Null_unspecified";
1201 llvm_unreachable("unhandled nullability");
1206 OS << " __attribute__((";
1207 switch (T->getAttrKind()) {
1208 default: llvm_unreachable("This attribute should have been handled already");
1209 case AttributedType::attr_address_space:
1210 OS << "address_space(";
1211 OS << T->getEquivalentType().getAddressSpace();
1215 case AttributedType::attr_vector_size: {
1216 OS << "__vector_size__(";
1217 if (const VectorType *vector =T->getEquivalentType()->getAs<VectorType>()) {
1218 OS << vector->getNumElements();
1220 print(vector->getElementType(), OS, StringRef());
1227 case AttributedType::attr_neon_vector_type:
1228 case AttributedType::attr_neon_polyvector_type: {
1229 if (T->getAttrKind() == AttributedType::attr_neon_vector_type)
1230 OS << "neon_vector_type(";
1232 OS << "neon_polyvector_type(";
1233 const VectorType *vector = T->getEquivalentType()->getAs<VectorType>();
1234 OS << vector->getNumElements();
1239 case AttributedType::attr_regparm: {
1240 // FIXME: When Sema learns to form this AttributedType, avoid printing the
1241 // attribute again in printFunctionProtoAfter.
1243 QualType t = T->getEquivalentType();
1244 while (!t->isFunctionType())
1245 t = t->getPointeeType();
1246 OS << t->getAs<FunctionType>()->getRegParmType();
1251 case AttributedType::attr_objc_gc: {
1254 QualType tmp = T->getEquivalentType();
1255 while (tmp.getObjCGCAttr() == Qualifiers::GCNone) {
1256 QualType next = tmp->getPointeeType();
1257 if (next == tmp) break;
1261 if (tmp.isObjCGCWeak())
1269 case AttributedType::attr_objc_ownership:
1270 OS << "objc_ownership(";
1271 switch (T->getEquivalentType().getObjCLifetime()) {
1272 case Qualifiers::OCL_None: llvm_unreachable("no ownership!");
1273 case Qualifiers::OCL_ExplicitNone: OS << "none"; break;
1274 case Qualifiers::OCL_Strong: OS << "strong"; break;
1275 case Qualifiers::OCL_Weak: OS << "weak"; break;
1276 case Qualifiers::OCL_Autoreleasing: OS << "autoreleasing"; break;
1281 // FIXME: When Sema learns to form this AttributedType, avoid printing the
1282 // attribute again in printFunctionProtoAfter.
1283 case AttributedType::attr_noreturn: OS << "noreturn"; break;
1285 case AttributedType::attr_cdecl: OS << "cdecl"; break;
1286 case AttributedType::attr_fastcall: OS << "fastcall"; break;
1287 case AttributedType::attr_stdcall: OS << "stdcall"; break;
1288 case AttributedType::attr_thiscall: OS << "thiscall"; break;
1289 case AttributedType::attr_vectorcall: OS << "vectorcall"; break;
1290 case AttributedType::attr_pascal: OS << "pascal"; break;
1291 case AttributedType::attr_ms_abi: OS << "ms_abi"; break;
1292 case AttributedType::attr_sysv_abi: OS << "sysv_abi"; break;
1293 case AttributedType::attr_pcs:
1294 case AttributedType::attr_pcs_vfp: {
1296 QualType t = T->getEquivalentType();
1297 while (!t->isFunctionType())
1298 t = t->getPointeeType();
1299 OS << (t->getAs<FunctionType>()->getCallConv() == CC_AAPCS ?
1300 "\"aapcs\"" : "\"aapcs-vfp\"");
1304 case AttributedType::attr_inteloclbicc: OS << "inteloclbicc"; break;
1309 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
1311 OS << T->getDecl()->getName();
1312 spaceBeforePlaceHolder(OS);
1314 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
1315 raw_ostream &OS) { }
1317 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
1319 if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1320 !T->isKindOfTypeAsWritten())
1321 return printBefore(T->getBaseType(), OS);
1323 if (T->isKindOfTypeAsWritten())
1326 print(T->getBaseType(), OS, StringRef());
1328 if (T->isSpecializedAsWritten()) {
1329 bool isFirst = true;
1331 for (auto typeArg : T->getTypeArgsAsWritten()) {
1337 print(typeArg, OS, StringRef());
1342 if (!T->qual_empty()) {
1343 bool isFirst = true;
1345 for (const auto *I : T->quals()) {
1355 spaceBeforePlaceHolder(OS);
1357 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
1359 if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1360 !T->isKindOfTypeAsWritten())
1361 return printAfter(T->getBaseType(), OS);
1364 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
1366 printBefore(T->getPointeeType(), OS);
1368 // If we need to print the pointer, print it now.
1369 if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() &&
1370 !T->isObjCClassType() && !T->isObjCQualifiedClassType()) {
1371 if (HasEmptyPlaceHolder)
1376 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
1377 raw_ostream &OS) { }
1379 void TemplateSpecializationType::
1380 PrintTemplateArgumentList(raw_ostream &OS,
1381 const TemplateArgumentListInfo &Args,
1382 const PrintingPolicy &Policy) {
1383 return PrintTemplateArgumentList(OS,
1384 Args.getArgumentArray(),
1390 TemplateSpecializationType::PrintTemplateArgumentList(
1392 const TemplateArgument *Args,
1394 const PrintingPolicy &Policy,
1395 bool SkipBrackets) {
1399 bool needSpace = false;
1400 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
1401 // Print the argument into a string.
1402 SmallString<128> Buf;
1403 llvm::raw_svector_ostream ArgOS(Buf);
1404 if (Args[Arg].getKind() == TemplateArgument::Pack) {
1405 if (Args[Arg].pack_size() && Arg > 0)
1407 PrintTemplateArgumentList(ArgOS,
1408 Args[Arg].pack_begin(),
1409 Args[Arg].pack_size(),
1414 Args[Arg].print(Policy, ArgOS);
1416 StringRef ArgString = ArgOS.str();
1418 // If this is the first argument and its string representation
1419 // begins with the global scope specifier ('::foo'), add a space
1420 // to avoid printing the diagraph '<:'.
1421 if (!Arg && !ArgString.empty() && ArgString[0] == ':')
1426 needSpace = (!ArgString.empty() && ArgString.back() == '>');
1429 // If the last character of our string is '>', add another space to
1430 // keep the two '>''s separate tokens. We don't *have* to do this in
1431 // C++0x, but it's still good hygiene.
1439 // Sadly, repeat all that with TemplateArgLoc.
1440 void TemplateSpecializationType::
1441 PrintTemplateArgumentList(raw_ostream &OS,
1442 const TemplateArgumentLoc *Args, unsigned NumArgs,
1443 const PrintingPolicy &Policy) {
1446 bool needSpace = false;
1447 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
1451 // Print the argument into a string.
1452 SmallString<128> Buf;
1453 llvm::raw_svector_ostream ArgOS(Buf);
1454 if (Args[Arg].getArgument().getKind() == TemplateArgument::Pack) {
1455 PrintTemplateArgumentList(ArgOS,
1456 Args[Arg].getArgument().pack_begin(),
1457 Args[Arg].getArgument().pack_size(),
1460 Args[Arg].getArgument().print(Policy, ArgOS);
1462 StringRef ArgString = ArgOS.str();
1464 // If this is the first argument and its string representation
1465 // begins with the global scope specifier ('::foo'), add a space
1466 // to avoid printing the diagraph '<:'.
1467 if (!Arg && !ArgString.empty() && ArgString[0] == ':')
1472 needSpace = (!ArgString.empty() && ArgString.back() == '>');
1475 // If the last character of our string is '>', add another space to
1476 // keep the two '>''s separate tokens. We don't *have* to do this in
1477 // C++0x, but it's still good hygiene.
1484 std::string Qualifiers::getAsString() const {
1486 return getAsString(PrintingPolicy(LO));
1489 // Appends qualifiers to the given string, separated by spaces. Will
1490 // prefix a space if the string is non-empty. Will not append a final
1492 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
1493 SmallString<64> Buf;
1494 llvm::raw_svector_ostream StrOS(Buf);
1495 print(StrOS, Policy);
1499 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
1500 if (getCVRQualifiers())
1503 if (getAddressSpace())
1506 if (getObjCGCAttr())
1509 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
1510 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
1516 // Appends qualifiers to the given string, separated by spaces. Will
1517 // prefix a space if the string is non-empty. Will not append a final
1519 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
1520 bool appendSpaceIfNonEmpty) const {
1521 bool addSpace = false;
1523 unsigned quals = getCVRQualifiers();
1525 AppendTypeQualList(OS, quals, Policy.LangOpts.C99);
1528 if (unsigned addrspace = getAddressSpace()) {
1532 switch (addrspace) {
1533 case LangAS::opencl_global:
1536 case LangAS::opencl_local:
1539 case LangAS::opencl_constant:
1542 case LangAS::opencl_generic:
1546 OS << "__attribute__((address_space(";
1551 if (Qualifiers::GC gc = getObjCGCAttr()) {
1555 if (gc == Qualifiers::Weak)
1560 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
1561 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
1568 case Qualifiers::OCL_None: llvm_unreachable("none but true");
1569 case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
1570 case Qualifiers::OCL_Strong:
1571 if (!Policy.SuppressStrongLifetime)
1575 case Qualifiers::OCL_Weak: OS << "__weak"; break;
1576 case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
1580 if (appendSpaceIfNonEmpty && addSpace)
1584 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
1586 getAsStringInternal(S, Policy);
1590 std::string QualType::getAsString(const Type *ty, Qualifiers qs) {
1592 LangOptions options;
1593 getAsStringInternal(ty, qs, buffer, PrintingPolicy(options));
1597 void QualType::print(const Type *ty, Qualifiers qs,
1598 raw_ostream &OS, const PrintingPolicy &policy,
1599 const Twine &PlaceHolder) {
1600 SmallString<128> PHBuf;
1601 StringRef PH = PlaceHolder.toStringRef(PHBuf);
1603 TypePrinter(policy).print(ty, qs, OS, PH);
1606 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
1607 std::string &buffer,
1608 const PrintingPolicy &policy) {
1609 SmallString<256> Buf;
1610 llvm::raw_svector_ostream StrOS(Buf);
1611 TypePrinter(policy).print(ty, qs, StrOS, buffer);
1612 std::string str = StrOS.str();