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 13#include "clang/AST/PrettyPrinter.h" 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" 21#include "clang/AST/NestedNameSpecifier.h" 22#include "clang/AST/TemplateBase.h" 23#include "clang/AST/TemplateName.h" 24#include "clang/AST/Type.h" 25#include "clang/Basic/AddressSpaces.h" 26#include "clang/Basic/ExceptionSpecificationType.h" 27#include "clang/Basic/IdentifierTable.h" 28#include "clang/Basic/LLVM.h" 29#include "clang/Basic/LangOptions.h" 30#include "clang/Basic/SourceLocation.h" 31#include "clang/Basic/SourceManager.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 45using namespace clang; 46 47namespace { 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 137static 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 159void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) { 160 if (!HasEmptyPlaceHolder) 161 OS << ' '; 162} 163 164static SplitQualType splitAccordingToPolicy(QualType QT, 165 const PrintingPolicy &Policy) { 166 if (Policy.PrintCanonicalTypes) 167 QT = QT.getCanonicalType(); 168 return QT.split(); 169} 170 171void 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 176void 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 190bool 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() || 235 T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType(); 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 277void TypePrinter::printBefore(QualType T, raw_ostream &OS) { 278 SplitQualType Split = splitAccordingToPolicy(T, Policy); 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 ". 291void 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 337void 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]". 344void 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 354void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) { 355 OS << T->getName(Policy); 356 spaceBeforePlaceHolder(OS); 357} 358 359void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {} 360 361void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) { 362 OS << "_Complex "; 363 printBefore(T->getElementType(), OS); 364} 365 366void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) { 367 printAfter(T->getElementType(), OS); 368} 369 370void 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 381void 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 391void TypePrinter::printBlockPointerBefore(const BlockPointerType *T, 392 raw_ostream &OS) { 393 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 394 printBefore(T->getPointeeType(), OS); 395 OS << '^'; 396} 397 398void 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. 406static QualType skipTopLevelReferences(QualType T) { 407 if (auto *Ref = T->getAs<ReferenceType>()) 408 return skipTopLevelReferences(Ref->getPointeeTypeAsWritten()); 409 return T; 410} 411 412void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T, 413 raw_ostream &OS) { 414 IncludeStrongLifetimeRAII Strong(Policy); 415 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 416 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 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 425void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T, 426 raw_ostream &OS) { 427 IncludeStrongLifetimeRAII Strong(Policy); 428 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 429 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 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 437void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T, 438 raw_ostream &OS) { 439 IncludeStrongLifetimeRAII Strong(Policy); 440 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 441 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 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 450void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T, 451 raw_ostream &OS) { 452 IncludeStrongLifetimeRAII Strong(Policy); 453 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 454 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 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 462void 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 479void 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 490void 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 497void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T, 498 raw_ostream &OS) { 499 OS << '['; 500 if (T->getIndexTypeQualifiers().hasQualifiers()) { 501 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), 502 Policy.Restrict); 503 OS << ' '; 504 } 505 506 if (T->getSizeModifier() == ArrayType::Static) 507 OS << "static "; 508 509 OS << T->getSize().getZExtValue() << ']'; 510 printAfter(T->getElementType(), OS); 511} 512 513void 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 520void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T, 521 raw_ostream &OS) { 522 OS << "[]"; 523 printAfter(T->getElementType(), OS); 524} 525 526void 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 533void TypePrinter::printVariableArrayAfter(const VariableArrayType *T, 534 raw_ostream &OS) { 535 OS << '['; 536 if (T->getIndexTypeQualifiers().hasQualifiers()) { 537 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.Restrict); 538 OS << ' '; 539 } 540 541 if (T->getSizeModifier() == VariableArrayType::Static) 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 553void 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 559void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) { 560 printAfter(T->getAdjustedType(), OS); 561} 562 563void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) { 564 // Print as though it's a pointer. 565 printAdjustedBefore(T, OS); 566} 567 568void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) { 569 printAdjustedAfter(T, OS); 570} 571 572void 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 580void 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 590void TypePrinter::printDependentAddressSpaceBefore( 591 const DependentAddressSpaceType *T, raw_ostream &OS) { 592 printBefore(T->getPointeeType(), OS); 593} 594 595void 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 604void TypePrinter::printDependentSizedExtVectorBefore( 605 const DependentSizedExtVectorType *T, 606 raw_ostream &OS) { 607 printBefore(T->getElementType(), OS); 608} 609 610void TypePrinter::printDependentSizedExtVectorAfter( 611 const DependentSizedExtVectorType *T, 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 620void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) { 621 switch (T->getVectorKind()) { 622 case VectorType::AltiVecPixel: 623 OS << "__vector __pixel "; 624 break; 625 case VectorType::AltiVecBool: 626 OS << "__vector __bool "; 627 printBefore(T->getElementType(), OS); 628 break; 629 case VectorType::AltiVecVector: 630 OS << "__vector "; 631 printBefore(T->getElementType(), OS); 632 break; 633 case VectorType::NeonVector: 634 OS << "__attribute__((neon_vector_type(" 635 << T->getNumElements() << "))) "; 636 printBefore(T->getElementType(), OS); 637 break; 638 case VectorType::NeonPolyVector: 639 OS << "__attribute__((neon_polyvector_type(" << 640 T->getNumElements() << "))) "; 641 printBefore(T->getElementType(), OS); 642 break; 643 case VectorType::GenericVector: { 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 657void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) { 658 printAfter(T->getElementType(), OS); 659} 660 661void TypePrinter::printDependentVectorBefore( 662 const DependentVectorType *T, raw_ostream &OS) { 663 switch (T->getVectorKind()) { 664 case VectorType::AltiVecPixel: 665 OS << "__vector __pixel "; 666 break; 667 case VectorType::AltiVecBool: 668 OS << "__vector __bool "; 669 printBefore(T->getElementType(), OS); 670 break; 671 case VectorType::AltiVecVector: 672 OS << "__vector "; 673 printBefore(T->getElementType(), OS); 674 break; 675 case VectorType::NeonVector: 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; 682 case VectorType::NeonPolyVector: 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; 689 case VectorType::GenericVector: { 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 704void TypePrinter::printDependentVectorAfter( 705 const DependentVectorType *T, raw_ostream &OS) { 706 printAfter(T->getElementType(), OS); 707} 708 709void TypePrinter::printExtVectorBefore(const ExtVectorType *T, 710 raw_ostream &OS) { 711 printBefore(T->getElementType(), OS); 712} 713 714void 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 721void 722FunctionProtoType::printExceptionSpecification(raw_ostream &OS, 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 752void 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 767StringRef clang::getParameterABISpelling(ParameterABI ABI) { 768 switch (ABI) { 769 case ParameterABI::Ordinary: 770 llvm_unreachable("asking for spelling of ordinary parameter ABI"); 771 case ParameterABI::SwiftContext: 772 return "swift_context"; 773 case ParameterABI::SwiftErrorResult: 774 return "swift_error_result"; 775 case ParameterABI::SwiftIndirectResult: 776 return "swift_indirect_result"; 777 } 778 llvm_unreachable("bad parameter ABI kind"); 779} 780 781void 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 845void 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; 879 case CC_AArch64VectorCall: 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 923void 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 932void 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 944void 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 957void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T, 958 raw_ostream &OS) { 959 printTypeSpec(T->getDecl(), OS); 960} 961 962void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T, 963 raw_ostream &OS) {} 964 965void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) { 966 printTypeSpec(T->getDecl(), OS); 967} 968 969void 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 979void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T, 980 raw_ostream &OS) { 981 printAfter(T->getModifiedType(), OS); 982} 983 984void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {} 985 986void 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 994void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T, 995 raw_ostream &OS) {} 996 997void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) { 998 OS << "typeof("; 999 print(T->getUnderlyingType(), OS, StringRef()); 1000 OS << ')'; 1001 spaceBeforePlaceHolder(OS); 1002} 1003 1004void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {} 1005 1006void 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 1014void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {} 1015 1016void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T, 1017 raw_ostream &OS) { 1018 IncludeStrongLifetimeRAII Strong(Policy); 1019 1020 switch (T->getUTTKind()) { 1021 case UnaryTransformType::EnumUnderlyingType: 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 1032void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T, 1033 raw_ostream &OS) { 1034 IncludeStrongLifetimeRAII Strong(Policy); 1035 1036 switch (T->getUTTKind()) { 1037 case UnaryTransformType::EnumUnderlyingType: 1038 return; 1039 } 1040 1041 printAfter(T->getBaseType(), OS); 1042} 1043 1044void 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 if (T->isConstrained()) { 1050 OS << T->getTypeConstraintConcept()->getName(); 1051 auto Args = T->getTypeConstraintArguments(); 1052 if (!Args.empty()) 1053 printTemplateArgumentList(OS, Args, Policy); 1054 OS << ' '; 1055 } 1056 switch (T->getKeyword()) { 1057 case AutoTypeKeyword::Auto: OS << "auto"; break; 1058 case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break; 1059 case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break; 1060 } 1061 spaceBeforePlaceHolder(OS); 1062 } 1063} 1064 1065void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) { 1066 // If the type has been deduced, do not print 'auto'. 1067 if (!T->getDeducedType().isNull()) 1068 printAfter(T->getDeducedType(), OS); 1069} 1070 1071void TypePrinter::printDeducedTemplateSpecializationBefore( 1072 const DeducedTemplateSpecializationType *T, raw_ostream &OS) { 1073 // If the type has been deduced, print the deduced type. 1074 if (!T->getDeducedType().isNull()) { 1075 printBefore(T->getDeducedType(), OS); 1076 } else { 1077 IncludeStrongLifetimeRAII Strong(Policy); 1078 T->getTemplateName().print(OS, Policy); 1079 spaceBeforePlaceHolder(OS); 1080 } 1081} 1082 1083void TypePrinter::printDeducedTemplateSpecializationAfter( 1084 const DeducedTemplateSpecializationType *T, raw_ostream &OS) { 1085 // If the type has been deduced, print the deduced type. 1086 if (!T->getDeducedType().isNull()) 1087 printAfter(T->getDeducedType(), OS); 1088} 1089 1090void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) { 1091 IncludeStrongLifetimeRAII Strong(Policy); 1092 1093 OS << "_Atomic("; 1094 print(T->getValueType(), OS, StringRef()); 1095 OS << ')'; 1096 spaceBeforePlaceHolder(OS); 1097} 1098 1099void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {} 1100 1101void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) { 1102 IncludeStrongLifetimeRAII Strong(Policy); 1103 1104 if (T->isReadOnly()) 1105 OS << "read_only "; 1106 else 1107 OS << "write_only "; 1108 OS << "pipe "; 1109 print(T->getElementType(), OS, StringRef()); 1110 spaceBeforePlaceHolder(OS); 1111} 1112 1113void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {} 1114 1115/// Appends the given scope to the end of a string. 1116void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) { 1117 if (DC->isTranslationUnit()) return; 1118 if (DC->isFunctionOrMethod()) return; 1119 AppendScope(DC->getParent(), OS); 1120 1121 if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) { 1122 if (Policy.SuppressUnwrittenScope && 1123 (NS->isAnonymousNamespace() || NS->isInline())) 1124 return; 1125 if (NS->getIdentifier()) 1126 OS << NS->getName() << "::"; 1127 else 1128 OS << "(anonymous namespace)::"; 1129 } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) { 1130 IncludeStrongLifetimeRAII Strong(Policy); 1131 OS << Spec->getIdentifier()->getName(); 1132 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1133 printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy); 1134 OS << "::"; 1135 } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) { 1136 if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl()) 1137 OS << Typedef->getIdentifier()->getName() << "::"; 1138 else if (Tag->getIdentifier()) 1139 OS << Tag->getIdentifier()->getName() << "::"; 1140 else 1141 return; 1142 } 1143} 1144 1145void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) { 1146 if (Policy.IncludeTagDefinition) { 1147 PrintingPolicy SubPolicy = Policy; 1148 SubPolicy.IncludeTagDefinition = false; 1149 D->print(OS, SubPolicy, Indentation); 1150 spaceBeforePlaceHolder(OS); 1151 return; 1152 } 1153 1154 bool HasKindDecoration = false; 1155 1156 // We don't print tags unless this is an elaborated type. 1157 // In C, we just assume every RecordType is an elaborated type. 1158 if (!Policy.SuppressTagKeyword && !D->getTypedefNameForAnonDecl()) { 1159 HasKindDecoration = true; 1160 OS << D->getKindName(); 1161 OS << ' '; 1162 } 1163 1164 // Compute the full nested-name-specifier for this type. 1165 // In C, this will always be empty except when the type 1166 // being printed is anonymous within other Record. 1167 if (!Policy.SuppressScope) 1168 AppendScope(D->getDeclContext(), OS); 1169 1170 if (const IdentifierInfo *II = D->getIdentifier()) 1171 OS << II->getName(); 1172 else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) { 1173 assert(Typedef->getIdentifier() && "Typedef without identifier?"); 1174 OS << Typedef->getIdentifier()->getName(); 1175 } else { 1176 // Make an unambiguous representation for anonymous types, e.g. 1177 // (anonymous enum at /usr/include/string.h:120:9) 1178 OS << (Policy.MSVCFormatting ? '`' : '('); 1179 1180 if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) { 1181 OS << "lambda"; 1182 HasKindDecoration = true; 1183 } else { 1184 OS << "anonymous"; 1185 } 1186 1187 if (Policy.AnonymousTagLocations) { 1188 // Suppress the redundant tag keyword if we just printed one. 1189 // We don't have to worry about ElaboratedTypes here because you can't 1190 // refer to an anonymous type with one. 1191 if (!HasKindDecoration) 1192 OS << " " << D->getKindName(); 1193 1194 PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc( 1195 D->getLocation()); 1196 if (PLoc.isValid()) { 1197 OS << " at "; 1198 StringRef File = PLoc.getFilename(); 1199 if (auto *Callbacks = Policy.Callbacks) 1200 OS << Callbacks->remapPath(File); 1201 else 1202 OS << File; 1203 OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn(); 1204 } 1205 } 1206 1207 OS << (Policy.MSVCFormatting ? '\'' : ')'); 1208 } 1209 1210 // If this is a class template specialization, print the template 1211 // arguments. 1212 if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 1213 ArrayRef<TemplateArgument> Args; 1214 TypeSourceInfo *TAW = Spec->getTypeAsWritten(); 1215 if (!Policy.PrintCanonicalTypes && TAW) { 1216 const TemplateSpecializationType *TST = 1217 cast<TemplateSpecializationType>(TAW->getType()); 1218 Args = TST->template_arguments(); 1219 } else { 1220 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1221 Args = TemplateArgs.asArray(); 1222 } 1223 IncludeStrongLifetimeRAII Strong(Policy); 1224 printTemplateArgumentList(OS, Args, Policy); 1225 } 1226 1227 spaceBeforePlaceHolder(OS); 1228} 1229 1230void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) { 1231 printTag(T->getDecl(), OS); 1232} 1233 1234void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {} 1235 1236void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) { 1237 printTag(T->getDecl(), OS); 1238} 1239 1240void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {} 1241 1242void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T, 1243 raw_ostream &OS) { 1244 TemplateTypeParmDecl *D = T->getDecl(); 1245 if (D && D->isImplicit()) { 1246 if (auto *TC = D->getTypeConstraint()) { 1247 TC->print(OS, Policy); 1248 OS << ' '; 1249 } 1250 OS << "auto"; 1251 } else if (IdentifierInfo *Id = T->getIdentifier()) 1252 OS << Id->getName(); 1253 else 1254 OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex(); 1255 1256 spaceBeforePlaceHolder(OS); 1257} 1258 1259void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T, 1260 raw_ostream &OS) {} 1261 1262void TypePrinter::printSubstTemplateTypeParmBefore( 1263 const SubstTemplateTypeParmType *T, 1264 raw_ostream &OS) { 1265 IncludeStrongLifetimeRAII Strong(Policy); 1266 printBefore(T->getReplacementType(), OS); 1267} 1268 1269void TypePrinter::printSubstTemplateTypeParmAfter( 1270 const SubstTemplateTypeParmType *T, 1271 raw_ostream &OS) { 1272 IncludeStrongLifetimeRAII Strong(Policy); 1273 printAfter(T->getReplacementType(), OS); 1274} 1275 1276void TypePrinter::printSubstTemplateTypeParmPackBefore( 1277 const SubstTemplateTypeParmPackType *T, 1278 raw_ostream &OS) { 1279 IncludeStrongLifetimeRAII Strong(Policy); 1280 printTemplateTypeParmBefore(T->getReplacedParameter(), OS); 1281} 1282 1283void TypePrinter::printSubstTemplateTypeParmPackAfter( 1284 const SubstTemplateTypeParmPackType *T, 1285 raw_ostream &OS) { 1286 IncludeStrongLifetimeRAII Strong(Policy); 1287 printTemplateTypeParmAfter(T->getReplacedParameter(), OS); 1288} 1289 1290void TypePrinter::printTemplateSpecializationBefore( 1291 const TemplateSpecializationType *T, 1292 raw_ostream &OS) { 1293 IncludeStrongLifetimeRAII Strong(Policy); 1294 T->getTemplateName().print(OS, Policy); 1295 1296 printTemplateArgumentList(OS, T->template_arguments(), Policy); 1297 spaceBeforePlaceHolder(OS); 1298} 1299 1300void TypePrinter::printTemplateSpecializationAfter( 1301 const TemplateSpecializationType *T, 1302 raw_ostream &OS) {} 1303 1304void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T, 1305 raw_ostream &OS) { 1306 printTemplateSpecializationBefore(T->getInjectedTST(), OS); 1307} 1308 1309void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T, 1310 raw_ostream &OS) {} 1311 1312void TypePrinter::printElaboratedBefore(const ElaboratedType *T, 1313 raw_ostream &OS) { 1314 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) { 1315 TagDecl *OwnedTagDecl = T->getOwnedTagDecl(); 1316 assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() && 1317 "OwnedTagDecl expected to be a declaration for the type"); 1318 PrintingPolicy SubPolicy = Policy; 1319 SubPolicy.IncludeTagDefinition = false; 1320 OwnedTagDecl->print(OS, SubPolicy, Indentation); 1321 spaceBeforePlaceHolder(OS); 1322 return; 1323 } 1324 1325 // The tag definition will take care of these. 1326 if (!Policy.IncludeTagDefinition) 1327 { 1328 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1329 if (T->getKeyword() != ETK_None) 1330 OS << " "; 1331 NestedNameSpecifier *Qualifier = T->getQualifier(); 1332 if (Qualifier) 1333 Qualifier->print(OS, Policy); 1334 } 1335 1336 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1337 printBefore(T->getNamedType(), OS); 1338} 1339 1340void TypePrinter::printElaboratedAfter(const ElaboratedType *T, 1341 raw_ostream &OS) { 1342 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) 1343 return; 1344 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1345 printAfter(T->getNamedType(), OS); 1346} 1347 1348void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) { 1349 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1350 printBefore(T->getInnerType(), OS); 1351 OS << '('; 1352 } else 1353 printBefore(T->getInnerType(), OS); 1354} 1355 1356void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) { 1357 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1358 OS << ')'; 1359 printAfter(T->getInnerType(), OS); 1360 } else 1361 printAfter(T->getInnerType(), OS); 1362} 1363 1364void TypePrinter::printDependentNameBefore(const DependentNameType *T, 1365 raw_ostream &OS) { 1366 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1367 if (T->getKeyword() != ETK_None) 1368 OS << " "; 1369 1370 T->getQualifier()->print(OS, Policy); 1371 1372 OS << T->getIdentifier()->getName(); 1373 spaceBeforePlaceHolder(OS); 1374} 1375 1376void TypePrinter::printDependentNameAfter(const DependentNameType *T, 1377 raw_ostream &OS) {} 1378 1379void TypePrinter::printDependentTemplateSpecializationBefore( 1380 const DependentTemplateSpecializationType *T, raw_ostream &OS) { 1381 IncludeStrongLifetimeRAII Strong(Policy); 1382 1383 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1384 if (T->getKeyword() != ETK_None) 1385 OS << " "; 1386 1387 if (T->getQualifier()) 1388 T->getQualifier()->print(OS, Policy); 1389 OS << T->getIdentifier()->getName(); 1390 printTemplateArgumentList(OS, T->template_arguments(), Policy); 1391 spaceBeforePlaceHolder(OS); 1392} 1393 1394void TypePrinter::printDependentTemplateSpecializationAfter( 1395 const DependentTemplateSpecializationType *T, raw_ostream &OS) {} 1396 1397void TypePrinter::printPackExpansionBefore(const PackExpansionType *T, 1398 raw_ostream &OS) { 1399 printBefore(T->getPattern(), OS); 1400} 1401 1402void TypePrinter::printPackExpansionAfter(const PackExpansionType *T, 1403 raw_ostream &OS) { 1404 printAfter(T->getPattern(), OS); 1405 OS << "..."; 1406} 1407 1408void TypePrinter::printAttributedBefore(const AttributedType *T, 1409 raw_ostream &OS) { 1410 // FIXME: Generate this with TableGen. 1411 1412 // Prefer the macro forms of the GC and ownership qualifiers. 1413 if (T->getAttrKind() == attr::ObjCGC || 1414 T->getAttrKind() == attr::ObjCOwnership) 1415 return printBefore(T->getEquivalentType(), OS); 1416 1417 if (T->getAttrKind() == attr::ObjCKindOf) 1418 OS << "__kindof "; 1419 1420 if (T->getAttrKind() == attr::AddressSpace) 1421 printBefore(T->getEquivalentType(), OS); 1422 else 1423 printBefore(T->getModifiedType(), OS); 1424 1425 if (T->isMSTypeSpec()) { 1426 switch (T->getAttrKind()) { 1427 default: return; 1428 case attr::Ptr32: OS << " __ptr32"; break; 1429 case attr::Ptr64: OS << " __ptr64"; break; 1430 case attr::SPtr: OS << " __sptr"; break; 1431 case attr::UPtr: OS << " __uptr"; break; 1432 } 1433 spaceBeforePlaceHolder(OS); 1434 } 1435 1436 // Print nullability type specifiers. 1437 if (T->getImmediateNullability()) { 1438 if (T->getAttrKind() == attr::TypeNonNull) 1439 OS << " _Nonnull"; 1440 else if (T->getAttrKind() == attr::TypeNullable) 1441 OS << " _Nullable"; 1442 else if (T->getAttrKind() == attr::TypeNullUnspecified) 1443 OS << " _Null_unspecified"; 1444 else 1445 llvm_unreachable("unhandled nullability"); 1446 spaceBeforePlaceHolder(OS); 1447 } 1448} 1449 1450void TypePrinter::printAttributedAfter(const AttributedType *T, 1451 raw_ostream &OS) { 1452 // FIXME: Generate this with TableGen. 1453 1454 // Prefer the macro forms of the GC and ownership qualifiers. 1455 if (T->getAttrKind() == attr::ObjCGC || 1456 T->getAttrKind() == attr::ObjCOwnership) 1457 return printAfter(T->getEquivalentType(), OS); 1458 1459 // If this is a calling convention attribute, don't print the implicit CC from 1460 // the modified type. 1461 SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv()); 1462 1463 printAfter(T->getModifiedType(), OS); 1464 1465 // Some attributes are printed as qualifiers before the type, so we have 1466 // nothing left to do. 1467 if (T->getAttrKind() == attr::ObjCKindOf || 1468 T->isMSTypeSpec() || T->getImmediateNullability()) 1469 return; 1470 1471 // Don't print the inert __unsafe_unretained attribute at all. 1472 if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained) 1473 return; 1474 1475 // Don't print ns_returns_retained unless it had an effect. 1476 if (T->getAttrKind() == attr::NSReturnsRetained && 1477 !T->getEquivalentType()->castAs<FunctionType>() 1478 ->getExtInfo().getProducesResult()) 1479 return; 1480 1481 if (T->getAttrKind() == attr::LifetimeBound) { 1482 OS << " [[clang::lifetimebound]]"; 1483 return; 1484 } 1485 1486 // The printing of the address_space attribute is handled by the qualifier 1487 // since it is still stored in the qualifier. Return early to prevent printing 1488 // this twice. 1489 if (T->getAttrKind() == attr::AddressSpace) 1490 return; 1491 1492 OS << " __attribute__(("; 1493 switch (T->getAttrKind()) { 1494#define TYPE_ATTR(NAME) 1495#define DECL_OR_TYPE_ATTR(NAME) 1496#define ATTR(NAME) case attr::NAME: 1497#include "clang/Basic/AttrList.inc" 1498 llvm_unreachable("non-type attribute attached to type"); 1499 1500 case attr::OpenCLPrivateAddressSpace: 1501 case attr::OpenCLGlobalAddressSpace: 1502 case attr::OpenCLLocalAddressSpace: 1503 case attr::OpenCLConstantAddressSpace: 1504 case attr::OpenCLGenericAddressSpace: 1505 // FIXME: Update printAttributedBefore to print these once we generate 1506 // AttributedType nodes for them. 1507 break; 1508 1509 case attr::LifetimeBound: 1510 case attr::TypeNonNull: 1511 case attr::TypeNullable: 1512 case attr::TypeNullUnspecified: 1513 case attr::ObjCGC: 1514 case attr::ObjCInertUnsafeUnretained: 1515 case attr::ObjCKindOf: 1516 case attr::ObjCOwnership: 1517 case attr::Ptr32: 1518 case attr::Ptr64: 1519 case attr::SPtr: 1520 case attr::UPtr: 1521 case attr::AddressSpace: 1522 llvm_unreachable("This attribute should have been handled already"); 1523 1524 case attr::NSReturnsRetained: 1525 OS << "ns_returns_retained"; 1526 break; 1527 1528 // FIXME: When Sema learns to form this AttributedType, avoid printing the 1529 // attribute again in printFunctionProtoAfter. 1530 case attr::AnyX86NoCfCheck: OS << "nocf_check"; break; 1531 case attr::CDecl: OS << "cdecl"; break; 1532 case attr::FastCall: OS << "fastcall"; break; 1533 case attr::StdCall: OS << "stdcall"; break; 1534 case attr::ThisCall: OS << "thiscall"; break; 1535 case attr::SwiftCall: OS << "swiftcall"; break; 1536 case attr::VectorCall: OS << "vectorcall"; break; 1537 case attr::Pascal: OS << "pascal"; break; 1538 case attr::MSABI: OS << "ms_abi"; break; 1539 case attr::SysVABI: OS << "sysv_abi"; break; 1540 case attr::RegCall: OS << "regcall"; break; 1541 case attr::Pcs: { 1542 OS << "pcs("; 1543 QualType t = T->getEquivalentType(); 1544 while (!t->isFunctionType()) 1545 t = t->getPointeeType(); 1546 OS << (t->castAs<FunctionType>()->getCallConv() == CC_AAPCS ? 1547 "\"aapcs\"" : "\"aapcs-vfp\""); 1548 OS << ')'; 1549 break; 1550 } 1551 case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break; 1552 case attr::IntelOclBicc: OS << "inteloclbicc"; break; 1553 case attr::PreserveMost: 1554 OS << "preserve_most"; 1555 break; 1556 1557 case attr::PreserveAll: 1558 OS << "preserve_all"; 1559 break; 1560 case attr::NoDeref: 1561 OS << "noderef"; 1562 break; 1563 case attr::AcquireHandle: 1564 OS << "acquire_handle"; 1565 break; 1566 } 1567 OS << "))"; 1568} 1569 1570void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T, 1571 raw_ostream &OS) { 1572 OS << T->getDecl()->getName(); 1573 spaceBeforePlaceHolder(OS); 1574} 1575 1576void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T, 1577 raw_ostream &OS) {} 1578 1579void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T, 1580 raw_ostream &OS) { 1581 OS << T->getDecl()->getName(); 1582 if (!T->qual_empty()) { 1583 bool isFirst = true; 1584 OS << '<'; 1585 for (const auto *I : T->quals()) { 1586 if (isFirst) 1587 isFirst = false; 1588 else 1589 OS << ','; 1590 OS << I->getName(); 1591 } 1592 OS << '>'; 1593 } 1594 1595 spaceBeforePlaceHolder(OS); 1596} 1597 1598void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T, 1599 raw_ostream &OS) {} 1600 1601void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T, 1602 raw_ostream &OS) { 1603 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1604 !T->isKindOfTypeAsWritten()) 1605 return printBefore(T->getBaseType(), OS); 1606 1607 if (T->isKindOfTypeAsWritten()) 1608 OS << "__kindof "; 1609 1610 print(T->getBaseType(), OS, StringRef()); 1611 1612 if (T->isSpecializedAsWritten()) { 1613 bool isFirst = true; 1614 OS << '<'; 1615 for (auto typeArg : T->getTypeArgsAsWritten()) { 1616 if (isFirst) 1617 isFirst = false; 1618 else 1619 OS << ","; 1620 1621 print(typeArg, OS, StringRef()); 1622 } 1623 OS << '>'; 1624 } 1625 1626 if (!T->qual_empty()) { 1627 bool isFirst = true; 1628 OS << '<'; 1629 for (const auto *I : T->quals()) { 1630 if (isFirst) 1631 isFirst = false; 1632 else 1633 OS << ','; 1634 OS << I->getName(); 1635 } 1636 OS << '>'; 1637 } 1638 1639 spaceBeforePlaceHolder(OS); 1640} 1641 1642void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T, 1643 raw_ostream &OS) { 1644 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1645 !T->isKindOfTypeAsWritten()) 1646 return printAfter(T->getBaseType(), OS); 1647} 1648 1649void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T, 1650 raw_ostream &OS) { 1651 printBefore(T->getPointeeType(), OS); 1652 1653 // If we need to print the pointer, print it now. 1654 if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() && 1655 !T->isObjCClassType() && !T->isObjCQualifiedClassType()) { 1656 if (HasEmptyPlaceHolder) 1657 OS << ' '; 1658 OS << '*'; 1659 } 1660} 1661 1662void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T, 1663 raw_ostream &OS) {} 1664 1665static 1666const TemplateArgument &getArgument(const TemplateArgument &A) { return A; } 1667 1668static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) { 1669 return A.getArgument(); 1670} 1671 1672static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP, 1673 llvm::raw_ostream &OS) { 1674 A.print(PP, OS); 1675} 1676 1677static void printArgument(const TemplateArgumentLoc &A, 1678 const PrintingPolicy &PP, llvm::raw_ostream &OS) { 1679 const TemplateArgument::ArgKind &Kind = A.getArgument().getKind(); 1680 if (Kind == TemplateArgument::ArgKind::Type) 1681 return A.getTypeSourceInfo()->getType().print(OS, PP); 1682 return A.getArgument().print(PP, OS); 1683} 1684 1685template<typename TA> 1686static void printTo(raw_ostream &OS, ArrayRef<TA> Args, 1687 const PrintingPolicy &Policy, bool SkipBrackets) { 1688 const char *Comma = Policy.MSVCFormatting ? "," : ", "; 1689 if (!SkipBrackets) 1690 OS << '<'; 1691 1692 bool NeedSpace = false; 1693 bool FirstArg = true; 1694 for (const auto &Arg : Args) { 1695 // Print the argument into a string. 1696 SmallString<128> Buf; 1697 llvm::raw_svector_ostream ArgOS(Buf); 1698 const TemplateArgument &Argument = getArgument(Arg); 1699 if (Argument.getKind() == TemplateArgument::Pack) { 1700 if (Argument.pack_size() && !FirstArg) 1701 OS << Comma; 1702 printTo(ArgOS, Argument.getPackAsArray(), Policy, true); 1703 } else { 1704 if (!FirstArg) 1705 OS << Comma; 1706 // Tries to print the argument with location info if exists. 1707 printArgument(Arg, Policy, ArgOS); 1708 } 1709 StringRef ArgString = ArgOS.str(); 1710 1711 // If this is the first argument and its string representation 1712 // begins with the global scope specifier ('::foo'), add a space 1713 // to avoid printing the diagraph '<:'. 1714 if (FirstArg && !ArgString.empty() && ArgString[0] == ':') 1715 OS << ' '; 1716 1717 OS << ArgString; 1718 1719 NeedSpace = (!ArgString.empty() && ArgString.back() == '>'); 1720 FirstArg = false; 1721 } 1722 1723 // If the last character of our string is '>', add another space to 1724 // keep the two '>''s separate tokens. We don't *have* to do this in 1725 // C++0x, but it's still good hygiene. 1726 if (NeedSpace) 1727 OS << ' '; 1728 1729 if (!SkipBrackets) 1730 OS << '>'; 1731} 1732 1733void clang::printTemplateArgumentList(raw_ostream &OS, 1734 const TemplateArgumentListInfo &Args, 1735 const PrintingPolicy &Policy) { 1736 return printTo(OS, Args.arguments(), Policy, false); 1737} 1738 1739void clang::printTemplateArgumentList(raw_ostream &OS, 1740 ArrayRef<TemplateArgument> Args, 1741 const PrintingPolicy &Policy) { 1742 printTo(OS, Args, Policy, false); 1743} 1744 1745void clang::printTemplateArgumentList(raw_ostream &OS, 1746 ArrayRef<TemplateArgumentLoc> Args, 1747 const PrintingPolicy &Policy) { 1748 printTo(OS, Args, Policy, false); 1749} 1750 1751std::string Qualifiers::getAsString() const { 1752 LangOptions LO; 1753 return getAsString(PrintingPolicy(LO)); 1754} 1755 1756// Appends qualifiers to the given string, separated by spaces. Will 1757// prefix a space if the string is non-empty. Will not append a final 1758// space. 1759std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const { 1760 SmallString<64> Buf; 1761 llvm::raw_svector_ostream StrOS(Buf); 1762 print(StrOS, Policy); 1763 return StrOS.str(); 1764} 1765 1766bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const { 1767 if (getCVRQualifiers()) 1768 return false; 1769 1770 if (getAddressSpace() != LangAS::Default) 1771 return false; 1772 1773 if (getObjCGCAttr()) 1774 return false; 1775 1776 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) 1777 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)) 1778 return false; 1779 1780 return true; 1781} 1782 1783std::string Qualifiers::getAddrSpaceAsString(LangAS AS) { 1784 switch (AS) { 1785 case LangAS::Default: 1786 return ""; 1787 case LangAS::opencl_global: 1788 return "__global"; 1789 case LangAS::opencl_local: 1790 return "__local"; 1791 case LangAS::opencl_private: 1792 return "__private"; 1793 case LangAS::opencl_constant: 1794 return "__constant"; 1795 case LangAS::opencl_generic: 1796 return "__generic"; 1797 case LangAS::cuda_device: 1798 return "__device__"; 1799 case LangAS::cuda_constant: 1800 return "__constant__"; 1801 case LangAS::cuda_shared: 1802 return "__shared__"; 1803 case LangAS::ptr32_sptr: 1804 return "__sptr __ptr32"; 1805 case LangAS::ptr32_uptr: 1806 return "__uptr __ptr32"; 1807 case LangAS::ptr64: 1808 return "__ptr64"; 1809 default: 1810 return std::to_string(toTargetAddressSpace(AS)); 1811 } 1812} 1813 1814// Appends qualifiers to the given string, separated by spaces. Will 1815// prefix a space if the string is non-empty. Will not append a final 1816// space. 1817void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy, 1818 bool appendSpaceIfNonEmpty) const { 1819 bool addSpace = false; 1820 1821 unsigned quals = getCVRQualifiers(); 1822 if (quals) { 1823 AppendTypeQualList(OS, quals, Policy.Restrict); 1824 addSpace = true; 1825 } 1826 if (hasUnaligned()) { 1827 if (addSpace) 1828 OS << ' '; 1829 OS << "__unaligned"; 1830 addSpace = true; 1831 } 1832 auto ASStr = getAddrSpaceAsString(getAddressSpace()); 1833 if (!ASStr.empty()) { 1834 if (addSpace) 1835 OS << ' '; 1836 addSpace = true; 1837 // Wrap target address space into an attribute syntax 1838 if (isTargetAddressSpace(getAddressSpace())) 1839 OS << "__attribute__((address_space(" << ASStr << ")))"; 1840 else 1841 OS << ASStr; 1842 } 1843 1844 if (Qualifiers::GC gc = getObjCGCAttr()) { 1845 if (addSpace) 1846 OS << ' '; 1847 addSpace = true; 1848 if (gc == Qualifiers::Weak) 1849 OS << "__weak"; 1850 else 1851 OS << "__strong"; 1852 } 1853 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) { 1854 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){ 1855 if (addSpace) 1856 OS << ' '; 1857 addSpace = true; 1858 } 1859 1860 switch (lifetime) { 1861 case Qualifiers::OCL_None: llvm_unreachable("none but true"); 1862 case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break; 1863 case Qualifiers::OCL_Strong: 1864 if (!Policy.SuppressStrongLifetime) 1865 OS << "__strong"; 1866 break; 1867 1868 case Qualifiers::OCL_Weak: OS << "__weak"; break; 1869 case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break; 1870 } 1871 } 1872 1873 if (appendSpaceIfNonEmpty && addSpace) 1874 OS << ' '; 1875} 1876 1877std::string QualType::getAsString() const { 1878 return getAsString(split(), LangOptions()); 1879} 1880 1881std::string QualType::getAsString(const PrintingPolicy &Policy) const { 1882 std::string S; 1883 getAsStringInternal(S, Policy); 1884 return S; 1885} 1886 1887std::string QualType::getAsString(const Type *ty, Qualifiers qs, 1888 const PrintingPolicy &Policy) { 1889 std::string buffer; 1890 getAsStringInternal(ty, qs, buffer, Policy); 1891 return buffer; 1892} 1893 1894void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy, 1895 const Twine &PlaceHolder, unsigned Indentation) const { 1896 print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder, 1897 Indentation); 1898} 1899 1900void QualType::print(const Type *ty, Qualifiers qs, 1901 raw_ostream &OS, const PrintingPolicy &policy, 1902 const Twine &PlaceHolder, unsigned Indentation) { 1903 SmallString<128> PHBuf; 1904 StringRef PH = PlaceHolder.toStringRef(PHBuf); 1905 1906 TypePrinter(policy, Indentation).print(ty, qs, OS, PH); 1907} 1908 1909void QualType::getAsStringInternal(std::string &Str, 1910 const PrintingPolicy &Policy) const { 1911 return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str, 1912 Policy); 1913} 1914 1915void QualType::getAsStringInternal(const Type *ty, Qualifiers qs, 1916 std::string &buffer, 1917 const PrintingPolicy &policy) { 1918 SmallString<256> Buf; 1919 llvm::raw_svector_ostream StrOS(Buf); 1920 TypePrinter(policy).print(ty, qs, StrOS, buffer); 1921 std::string str = StrOS.str(); 1922 buffer.swap(str); 1923} 1924