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/ASTContext.h" 14#include "clang/AST/Attr.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/PrettyPrinter.h" 23#include "clang/AST/TemplateBase.h" 24#include "clang/AST/TemplateName.h" 25#include "clang/AST/Type.h" 26#include "clang/Basic/AddressSpaces.h" 27#include "clang/Basic/ExceptionSpecificationType.h" 28#include "clang/Basic/IdentifierTable.h" 29#include "clang/Basic/LLVM.h" 30#include "clang/Basic/LangOptions.h" 31#include "clang/Basic/SourceLocation.h" 32#include "clang/Basic/SourceManager.h" 33#include "clang/Basic/Specifiers.h" 34#include "llvm/ADT/ArrayRef.h" 35#include "llvm/ADT/SmallString.h" 36#include "llvm/ADT/StringRef.h" 37#include "llvm/ADT/Twine.h" 38#include "llvm/Support/Casting.h" 39#include "llvm/Support/Compiler.h" 40#include "llvm/Support/ErrorHandling.h" 41#include "llvm/Support/SaveAndRestore.h" 42#include "llvm/Support/raw_ostream.h" 43#include <cassert> 44#include <string> 45 46using namespace clang; 47 48namespace { 49 50 /// RAII object that enables printing of the ARC __strong lifetime 51 /// qualifier. 52 class IncludeStrongLifetimeRAII { 53 PrintingPolicy &Policy; 54 bool Old; 55 56 public: 57 explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy) 58 : Policy(Policy), Old(Policy.SuppressStrongLifetime) { 59 if (!Policy.SuppressLifetimeQualifiers) 60 Policy.SuppressStrongLifetime = false; 61 } 62 63 ~IncludeStrongLifetimeRAII() { 64 Policy.SuppressStrongLifetime = Old; 65 } 66 }; 67 68 class ParamPolicyRAII { 69 PrintingPolicy &Policy; 70 bool Old; 71 72 public: 73 explicit ParamPolicyRAII(PrintingPolicy &Policy) 74 : Policy(Policy), Old(Policy.SuppressSpecifiers) { 75 Policy.SuppressSpecifiers = false; 76 } 77 78 ~ParamPolicyRAII() { 79 Policy.SuppressSpecifiers = Old; 80 } 81 }; 82 83 class ElaboratedTypePolicyRAII { 84 PrintingPolicy &Policy; 85 bool SuppressTagKeyword; 86 bool SuppressScope; 87 88 public: 89 explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) { 90 SuppressTagKeyword = Policy.SuppressTagKeyword; 91 SuppressScope = Policy.SuppressScope; 92 Policy.SuppressTagKeyword = true; 93 Policy.SuppressScope = true; 94 } 95 96 ~ElaboratedTypePolicyRAII() { 97 Policy.SuppressTagKeyword = SuppressTagKeyword; 98 Policy.SuppressScope = SuppressScope; 99 } 100 }; 101 102 class TypePrinter { 103 PrintingPolicy Policy; 104 unsigned Indentation; 105 bool HasEmptyPlaceHolder = false; 106 bool InsideCCAttribute = false; 107 108 public: 109 explicit TypePrinter(const PrintingPolicy &Policy, unsigned Indentation = 0) 110 : Policy(Policy), Indentation(Indentation) {} 111 112 void print(const Type *ty, Qualifiers qs, raw_ostream &OS, 113 StringRef PlaceHolder); 114 void print(QualType T, raw_ostream &OS, StringRef PlaceHolder); 115 116 static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier); 117 void spaceBeforePlaceHolder(raw_ostream &OS); 118 void printTypeSpec(NamedDecl *D, raw_ostream &OS); 119 void printTemplateId(const TemplateSpecializationType *T, raw_ostream &OS, 120 bool FullyQualify); 121 122 void printBefore(QualType T, raw_ostream &OS); 123 void printAfter(QualType T, raw_ostream &OS); 124 void AppendScope(DeclContext *DC, raw_ostream &OS, 125 DeclarationName NameInScope); 126 void printTag(TagDecl *T, raw_ostream &OS); 127 void printFunctionAfter(const FunctionType::ExtInfo &Info, raw_ostream &OS); 128#define ABSTRACT_TYPE(CLASS, PARENT) 129#define TYPE(CLASS, PARENT) \ 130 void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \ 131 void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS); 132#include "clang/AST/TypeNodes.inc" 133 134 private: 135 void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS); 136 void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS); 137 }; 138 139} // namespace 140 141static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals, 142 bool HasRestrictKeyword) { 143 bool appendSpace = false; 144 if (TypeQuals & Qualifiers::Const) { 145 OS << "const"; 146 appendSpace = true; 147 } 148 if (TypeQuals & Qualifiers::Volatile) { 149 if (appendSpace) OS << ' '; 150 OS << "volatile"; 151 appendSpace = true; 152 } 153 if (TypeQuals & Qualifiers::Restrict) { 154 if (appendSpace) OS << ' '; 155 if (HasRestrictKeyword) { 156 OS << "restrict"; 157 } else { 158 OS << "__restrict"; 159 } 160 } 161} 162 163void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) { 164 if (!HasEmptyPlaceHolder) 165 OS << ' '; 166} 167 168static SplitQualType splitAccordingToPolicy(QualType QT, 169 const PrintingPolicy &Policy) { 170 if (Policy.PrintCanonicalTypes) 171 QT = QT.getCanonicalType(); 172 return QT.split(); 173} 174 175void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) { 176 SplitQualType split = splitAccordingToPolicy(t, Policy); 177 print(split.Ty, split.Quals, OS, PlaceHolder); 178} 179 180void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS, 181 StringRef PlaceHolder) { 182 if (!T) { 183 OS << "NULL TYPE"; 184 return; 185 } 186 187 SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty()); 188 189 printBefore(T, Quals, OS); 190 OS << PlaceHolder; 191 printAfter(T, Quals, OS); 192} 193 194bool TypePrinter::canPrefixQualifiers(const Type *T, 195 bool &NeedARCStrongQualifier) { 196 // CanPrefixQualifiers - We prefer to print type qualifiers before the type, 197 // so that we get "const int" instead of "int const", but we can't do this if 198 // the type is complex. For example if the type is "int*", we *must* print 199 // "int * const", printing "const int *" is different. Only do this when the 200 // type expands to a simple string. 201 bool CanPrefixQualifiers = false; 202 NeedARCStrongQualifier = false; 203 Type::TypeClass TC = T->getTypeClass(); 204 if (const auto *AT = dyn_cast<AutoType>(T)) 205 TC = AT->desugar()->getTypeClass(); 206 if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(T)) 207 TC = Subst->getReplacementType()->getTypeClass(); 208 209 switch (TC) { 210 case Type::Auto: 211 case Type::Builtin: 212 case Type::Complex: 213 case Type::UnresolvedUsing: 214 case Type::Typedef: 215 case Type::TypeOfExpr: 216 case Type::TypeOf: 217 case Type::Decltype: 218 case Type::UnaryTransform: 219 case Type::Record: 220 case Type::Enum: 221 case Type::Elaborated: 222 case Type::TemplateTypeParm: 223 case Type::SubstTemplateTypeParmPack: 224 case Type::DeducedTemplateSpecialization: 225 case Type::TemplateSpecialization: 226 case Type::InjectedClassName: 227 case Type::DependentName: 228 case Type::DependentTemplateSpecialization: 229 case Type::ObjCObject: 230 case Type::ObjCTypeParam: 231 case Type::ObjCInterface: 232 case Type::Atomic: 233 case Type::Pipe: 234 case Type::ExtInt: 235 case Type::DependentExtInt: 236 CanPrefixQualifiers = true; 237 break; 238 239 case Type::ObjCObjectPointer: 240 CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() || 241 T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType(); 242 break; 243 244 case Type::ConstantArray: 245 case Type::IncompleteArray: 246 case Type::VariableArray: 247 case Type::DependentSizedArray: 248 NeedARCStrongQualifier = true; 249 LLVM_FALLTHROUGH; 250 251 case Type::Adjusted: 252 case Type::Decayed: 253 case Type::Pointer: 254 case Type::BlockPointer: 255 case Type::LValueReference: 256 case Type::RValueReference: 257 case Type::MemberPointer: 258 case Type::DependentAddressSpace: 259 case Type::DependentVector: 260 case Type::DependentSizedExtVector: 261 case Type::Vector: 262 case Type::ExtVector: 263 case Type::ConstantMatrix: 264 case Type::DependentSizedMatrix: 265 case Type::FunctionProto: 266 case Type::FunctionNoProto: 267 case Type::Paren: 268 case Type::PackExpansion: 269 case Type::SubstTemplateTypeParm: 270 case Type::MacroQualified: 271 CanPrefixQualifiers = false; 272 break; 273 274 case Type::Attributed: { 275 // We still want to print the address_space before the type if it is an 276 // address_space attribute. 277 const auto *AttrTy = cast<AttributedType>(T); 278 CanPrefixQualifiers = AttrTy->getAttrKind() == attr::AddressSpace; 279 } 280 } 281 282 return CanPrefixQualifiers; 283} 284 285void TypePrinter::printBefore(QualType T, raw_ostream &OS) { 286 SplitQualType Split = splitAccordingToPolicy(T, Policy); 287 288 // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2 289 // at this level. 290 Qualifiers Quals = Split.Quals; 291 if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(Split.Ty)) 292 Quals -= QualType(Subst, 0).getQualifiers(); 293 294 printBefore(Split.Ty, Quals, OS); 295} 296 297/// Prints the part of the type string before an identifier, e.g. for 298/// "int foo[10]" it prints "int ". 299void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) { 300 if (Policy.SuppressSpecifiers && T->isSpecifierType()) 301 return; 302 303 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder); 304 305 // Print qualifiers as appropriate. 306 307 bool CanPrefixQualifiers = false; 308 bool NeedARCStrongQualifier = false; 309 CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier); 310 311 if (CanPrefixQualifiers && !Quals.empty()) { 312 if (NeedARCStrongQualifier) { 313 IncludeStrongLifetimeRAII Strong(Policy); 314 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true); 315 } else { 316 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true); 317 } 318 } 319 320 bool hasAfterQuals = false; 321 if (!CanPrefixQualifiers && !Quals.empty()) { 322 hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy); 323 if (hasAfterQuals) 324 HasEmptyPlaceHolder = false; 325 } 326 327 switch (T->getTypeClass()) { 328#define ABSTRACT_TYPE(CLASS, PARENT) 329#define TYPE(CLASS, PARENT) case Type::CLASS: \ 330 print##CLASS##Before(cast<CLASS##Type>(T), OS); \ 331 break; 332#include "clang/AST/TypeNodes.inc" 333 } 334 335 if (hasAfterQuals) { 336 if (NeedARCStrongQualifier) { 337 IncludeStrongLifetimeRAII Strong(Policy); 338 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get()); 339 } else { 340 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get()); 341 } 342 } 343} 344 345void TypePrinter::printAfter(QualType t, raw_ostream &OS) { 346 SplitQualType split = splitAccordingToPolicy(t, Policy); 347 printAfter(split.Ty, split.Quals, OS); 348} 349 350/// Prints the part of the type string after an identifier, e.g. for 351/// "int foo[10]" it prints "[10]". 352void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) { 353 switch (T->getTypeClass()) { 354#define ABSTRACT_TYPE(CLASS, PARENT) 355#define TYPE(CLASS, PARENT) case Type::CLASS: \ 356 print##CLASS##After(cast<CLASS##Type>(T), OS); \ 357 break; 358#include "clang/AST/TypeNodes.inc" 359 } 360} 361 362void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) { 363 OS << T->getName(Policy); 364 spaceBeforePlaceHolder(OS); 365} 366 367void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {} 368 369void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) { 370 OS << "_Complex "; 371 printBefore(T->getElementType(), OS); 372} 373 374void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) { 375 printAfter(T->getElementType(), OS); 376} 377 378void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) { 379 IncludeStrongLifetimeRAII Strong(Policy); 380 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 381 printBefore(T->getPointeeType(), OS); 382 // Handle things like 'int (*A)[4];' correctly. 383 // FIXME: this should include vectors, but vectors use attributes I guess. 384 if (isa<ArrayType>(T->getPointeeType())) 385 OS << '('; 386 OS << '*'; 387} 388 389void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) { 390 IncludeStrongLifetimeRAII Strong(Policy); 391 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 392 // Handle things like 'int (*A)[4];' correctly. 393 // FIXME: this should include vectors, but vectors use attributes I guess. 394 if (isa<ArrayType>(T->getPointeeType())) 395 OS << ')'; 396 printAfter(T->getPointeeType(), OS); 397} 398 399void TypePrinter::printBlockPointerBefore(const BlockPointerType *T, 400 raw_ostream &OS) { 401 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 402 printBefore(T->getPointeeType(), OS); 403 OS << '^'; 404} 405 406void TypePrinter::printBlockPointerAfter(const BlockPointerType *T, 407 raw_ostream &OS) { 408 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 409 printAfter(T->getPointeeType(), OS); 410} 411 412// When printing a reference, the referenced type might also be a reference. 413// If so, we want to skip that before printing the inner type. 414static QualType skipTopLevelReferences(QualType T) { 415 if (auto *Ref = T->getAs<ReferenceType>()) 416 return skipTopLevelReferences(Ref->getPointeeTypeAsWritten()); 417 return T; 418} 419 420void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T, 421 raw_ostream &OS) { 422 IncludeStrongLifetimeRAII Strong(Policy); 423 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 424 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 425 printBefore(Inner, OS); 426 // Handle things like 'int (&A)[4];' correctly. 427 // FIXME: this should include vectors, but vectors use attributes I guess. 428 if (isa<ArrayType>(Inner)) 429 OS << '('; 430 OS << '&'; 431} 432 433void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T, 434 raw_ostream &OS) { 435 IncludeStrongLifetimeRAII Strong(Policy); 436 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 437 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 438 // Handle things like 'int (&A)[4];' correctly. 439 // FIXME: this should include vectors, but vectors use attributes I guess. 440 if (isa<ArrayType>(Inner)) 441 OS << ')'; 442 printAfter(Inner, OS); 443} 444 445void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T, 446 raw_ostream &OS) { 447 IncludeStrongLifetimeRAII Strong(Policy); 448 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 449 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 450 printBefore(Inner, OS); 451 // Handle things like 'int (&&A)[4];' correctly. 452 // FIXME: this should include vectors, but vectors use attributes I guess. 453 if (isa<ArrayType>(Inner)) 454 OS << '('; 455 OS << "&&"; 456} 457 458void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T, 459 raw_ostream &OS) { 460 IncludeStrongLifetimeRAII Strong(Policy); 461 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 462 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 463 // Handle things like 'int (&&A)[4];' correctly. 464 // FIXME: this should include vectors, but vectors use attributes I guess. 465 if (isa<ArrayType>(Inner)) 466 OS << ')'; 467 printAfter(Inner, OS); 468} 469 470void TypePrinter::printMemberPointerBefore(const MemberPointerType *T, 471 raw_ostream &OS) { 472 IncludeStrongLifetimeRAII Strong(Policy); 473 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 474 printBefore(T->getPointeeType(), OS); 475 // Handle things like 'int (Cls::*A)[4];' correctly. 476 // FIXME: this should include vectors, but vectors use attributes I guess. 477 if (isa<ArrayType>(T->getPointeeType())) 478 OS << '('; 479 480 PrintingPolicy InnerPolicy(Policy); 481 InnerPolicy.IncludeTagDefinition = false; 482 TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef()); 483 484 OS << "::*"; 485} 486 487void TypePrinter::printMemberPointerAfter(const MemberPointerType *T, 488 raw_ostream &OS) { 489 IncludeStrongLifetimeRAII Strong(Policy); 490 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 491 // Handle things like 'int (Cls::*A)[4];' correctly. 492 // FIXME: this should include vectors, but vectors use attributes I guess. 493 if (isa<ArrayType>(T->getPointeeType())) 494 OS << ')'; 495 printAfter(T->getPointeeType(), OS); 496} 497 498void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T, 499 raw_ostream &OS) { 500 IncludeStrongLifetimeRAII Strong(Policy); 501 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 502 printBefore(T->getElementType(), OS); 503} 504 505void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T, 506 raw_ostream &OS) { 507 OS << '['; 508 if (T->getIndexTypeQualifiers().hasQualifiers()) { 509 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), 510 Policy.Restrict); 511 OS << ' '; 512 } 513 514 if (T->getSizeModifier() == ArrayType::Static) 515 OS << "static "; 516 517 OS << T->getSize().getZExtValue() << ']'; 518 printAfter(T->getElementType(), OS); 519} 520 521void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T, 522 raw_ostream &OS) { 523 IncludeStrongLifetimeRAII Strong(Policy); 524 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 525 printBefore(T->getElementType(), OS); 526} 527 528void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T, 529 raw_ostream &OS) { 530 OS << "[]"; 531 printAfter(T->getElementType(), OS); 532} 533 534void TypePrinter::printVariableArrayBefore(const VariableArrayType *T, 535 raw_ostream &OS) { 536 IncludeStrongLifetimeRAII Strong(Policy); 537 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 538 printBefore(T->getElementType(), OS); 539} 540 541void TypePrinter::printVariableArrayAfter(const VariableArrayType *T, 542 raw_ostream &OS) { 543 OS << '['; 544 if (T->getIndexTypeQualifiers().hasQualifiers()) { 545 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.Restrict); 546 OS << ' '; 547 } 548 549 if (T->getSizeModifier() == VariableArrayType::Static) 550 OS << "static "; 551 else if (T->getSizeModifier() == VariableArrayType::Star) 552 OS << '*'; 553 554 if (T->getSizeExpr()) 555 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 556 OS << ']'; 557 558 printAfter(T->getElementType(), OS); 559} 560 561void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) { 562 // Print the adjusted representation, otherwise the adjustment will be 563 // invisible. 564 printBefore(T->getAdjustedType(), OS); 565} 566 567void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) { 568 printAfter(T->getAdjustedType(), OS); 569} 570 571void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) { 572 // Print as though it's a pointer. 573 printAdjustedBefore(T, OS); 574} 575 576void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) { 577 printAdjustedAfter(T, OS); 578} 579 580void TypePrinter::printDependentSizedArrayBefore( 581 const DependentSizedArrayType *T, 582 raw_ostream &OS) { 583 IncludeStrongLifetimeRAII Strong(Policy); 584 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 585 printBefore(T->getElementType(), OS); 586} 587 588void TypePrinter::printDependentSizedArrayAfter( 589 const DependentSizedArrayType *T, 590 raw_ostream &OS) { 591 OS << '['; 592 if (T->getSizeExpr()) 593 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 594 OS << ']'; 595 printAfter(T->getElementType(), OS); 596} 597 598void TypePrinter::printDependentAddressSpaceBefore( 599 const DependentAddressSpaceType *T, raw_ostream &OS) { 600 printBefore(T->getPointeeType(), OS); 601} 602 603void TypePrinter::printDependentAddressSpaceAfter( 604 const DependentAddressSpaceType *T, raw_ostream &OS) { 605 OS << " __attribute__((address_space("; 606 if (T->getAddrSpaceExpr()) 607 T->getAddrSpaceExpr()->printPretty(OS, nullptr, Policy); 608 OS << ")))"; 609 printAfter(T->getPointeeType(), OS); 610} 611 612void TypePrinter::printDependentSizedExtVectorBefore( 613 const DependentSizedExtVectorType *T, 614 raw_ostream &OS) { 615 printBefore(T->getElementType(), OS); 616} 617 618void TypePrinter::printDependentSizedExtVectorAfter( 619 const DependentSizedExtVectorType *T, 620 raw_ostream &OS) { 621 OS << " __attribute__((ext_vector_type("; 622 if (T->getSizeExpr()) 623 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 624 OS << ")))"; 625 printAfter(T->getElementType(), OS); 626} 627 628void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) { 629 switch (T->getVectorKind()) { 630 case VectorType::AltiVecPixel: 631 OS << "__vector __pixel "; 632 break; 633 case VectorType::AltiVecBool: 634 OS << "__vector __bool "; 635 printBefore(T->getElementType(), OS); 636 break; 637 case VectorType::AltiVecVector: 638 OS << "__vector "; 639 printBefore(T->getElementType(), OS); 640 break; 641 case VectorType::NeonVector: 642 OS << "__attribute__((neon_vector_type(" 643 << T->getNumElements() << "))) "; 644 printBefore(T->getElementType(), OS); 645 break; 646 case VectorType::NeonPolyVector: 647 OS << "__attribute__((neon_polyvector_type(" << 648 T->getNumElements() << "))) "; 649 printBefore(T->getElementType(), OS); 650 break; 651 case VectorType::GenericVector: { 652 // FIXME: We prefer to print the size directly here, but have no way 653 // to get the size of the type. 654 OS << "__attribute__((__vector_size__(" 655 << T->getNumElements() 656 << " * sizeof("; 657 print(T->getElementType(), OS, StringRef()); 658 OS << ")))) "; 659 printBefore(T->getElementType(), OS); 660 break; 661 } 662 case VectorType::SveFixedLengthDataVector: 663 case VectorType::SveFixedLengthPredicateVector: 664 // FIXME: We prefer to print the size directly here, but have no way 665 // to get the size of the type. 666 OS << "__attribute__((__arm_sve_vector_bits__("; 667 668 if (T->getVectorKind() == VectorType::SveFixedLengthPredicateVector) 669 // Predicates take a bit per byte of the vector size, multiply by 8 to 670 // get the number of bits passed to the attribute. 671 OS << T->getNumElements() * 8; 672 else 673 OS << T->getNumElements(); 674 675 OS << " * sizeof("; 676 print(T->getElementType(), OS, StringRef()); 677 // Multiply by 8 for the number of bits. 678 OS << ") * 8))) "; 679 printBefore(T->getElementType(), OS); 680 } 681} 682 683void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) { 684 printAfter(T->getElementType(), OS); 685} 686 687void TypePrinter::printDependentVectorBefore( 688 const DependentVectorType *T, raw_ostream &OS) { 689 switch (T->getVectorKind()) { 690 case VectorType::AltiVecPixel: 691 OS << "__vector __pixel "; 692 break; 693 case VectorType::AltiVecBool: 694 OS << "__vector __bool "; 695 printBefore(T->getElementType(), OS); 696 break; 697 case VectorType::AltiVecVector: 698 OS << "__vector "; 699 printBefore(T->getElementType(), OS); 700 break; 701 case VectorType::NeonVector: 702 OS << "__attribute__((neon_vector_type("; 703 if (T->getSizeExpr()) 704 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 705 OS << "))) "; 706 printBefore(T->getElementType(), OS); 707 break; 708 case VectorType::NeonPolyVector: 709 OS << "__attribute__((neon_polyvector_type("; 710 if (T->getSizeExpr()) 711 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 712 OS << "))) "; 713 printBefore(T->getElementType(), OS); 714 break; 715 case VectorType::GenericVector: { 716 // FIXME: We prefer to print the size directly here, but have no way 717 // to get the size of the type. 718 OS << "__attribute__((__vector_size__("; 719 if (T->getSizeExpr()) 720 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 721 OS << " * sizeof("; 722 print(T->getElementType(), OS, StringRef()); 723 OS << ")))) "; 724 printBefore(T->getElementType(), OS); 725 break; 726 } 727 case VectorType::SveFixedLengthDataVector: 728 case VectorType::SveFixedLengthPredicateVector: 729 // FIXME: We prefer to print the size directly here, but have no way 730 // to get the size of the type. 731 OS << "__attribute__((__arm_sve_vector_bits__("; 732 if (T->getSizeExpr()) { 733 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 734 if (T->getVectorKind() == VectorType::SveFixedLengthPredicateVector) 735 // Predicates take a bit per byte of the vector size, multiply by 8 to 736 // get the number of bits passed to the attribute. 737 OS << " * 8"; 738 OS << " * sizeof("; 739 print(T->getElementType(), OS, StringRef()); 740 // Multiply by 8 for the number of bits. 741 OS << ") * 8"; 742 } 743 OS << "))) "; 744 printBefore(T->getElementType(), OS); 745 } 746} 747 748void TypePrinter::printDependentVectorAfter( 749 const DependentVectorType *T, raw_ostream &OS) { 750 printAfter(T->getElementType(), OS); 751} 752 753void TypePrinter::printExtVectorBefore(const ExtVectorType *T, 754 raw_ostream &OS) { 755 printBefore(T->getElementType(), OS); 756} 757 758void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) { 759 printAfter(T->getElementType(), OS); 760 OS << " __attribute__((ext_vector_type("; 761 OS << T->getNumElements(); 762 OS << ")))"; 763} 764 765void TypePrinter::printConstantMatrixBefore(const ConstantMatrixType *T, 766 raw_ostream &OS) { 767 printBefore(T->getElementType(), OS); 768 OS << " __attribute__((matrix_type("; 769 OS << T->getNumRows() << ", " << T->getNumColumns(); 770 OS << ")))"; 771} 772 773void TypePrinter::printConstantMatrixAfter(const ConstantMatrixType *T, 774 raw_ostream &OS) { 775 printAfter(T->getElementType(), OS); 776} 777 778void TypePrinter::printDependentSizedMatrixBefore( 779 const DependentSizedMatrixType *T, raw_ostream &OS) { 780 printBefore(T->getElementType(), OS); 781 OS << " __attribute__((matrix_type("; 782 if (T->getRowExpr()) { 783 T->getRowExpr()->printPretty(OS, nullptr, Policy); 784 } 785 OS << ", "; 786 if (T->getColumnExpr()) { 787 T->getColumnExpr()->printPretty(OS, nullptr, Policy); 788 } 789 OS << ")))"; 790} 791 792void TypePrinter::printDependentSizedMatrixAfter( 793 const DependentSizedMatrixType *T, raw_ostream &OS) { 794 printAfter(T->getElementType(), OS); 795} 796 797void 798FunctionProtoType::printExceptionSpecification(raw_ostream &OS, 799 const PrintingPolicy &Policy) 800 const { 801 if (hasDynamicExceptionSpec()) { 802 OS << " throw("; 803 if (getExceptionSpecType() == EST_MSAny) 804 OS << "..."; 805 else 806 for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) { 807 if (I) 808 OS << ", "; 809 810 OS << getExceptionType(I).stream(Policy); 811 } 812 OS << ')'; 813 } else if (EST_NoThrow == getExceptionSpecType()) { 814 OS << " __attribute__((nothrow))"; 815 } else if (isNoexceptExceptionSpec(getExceptionSpecType())) { 816 OS << " noexcept"; 817 // FIXME:Is it useful to print out the expression for a non-dependent 818 // noexcept specification? 819 if (isComputedNoexcept(getExceptionSpecType())) { 820 OS << '('; 821 if (getNoexceptExpr()) 822 getNoexceptExpr()->printPretty(OS, nullptr, Policy); 823 OS << ')'; 824 } 825 } 826} 827 828void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T, 829 raw_ostream &OS) { 830 if (T->hasTrailingReturn()) { 831 OS << "auto "; 832 if (!HasEmptyPlaceHolder) 833 OS << '('; 834 } else { 835 // If needed for precedence reasons, wrap the inner part in grouping parens. 836 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false); 837 printBefore(T->getReturnType(), OS); 838 if (!PrevPHIsEmpty.get()) 839 OS << '('; 840 } 841} 842 843StringRef clang::getParameterABISpelling(ParameterABI ABI) { 844 switch (ABI) { 845 case ParameterABI::Ordinary: 846 llvm_unreachable("asking for spelling of ordinary parameter ABI"); 847 case ParameterABI::SwiftContext: 848 return "swift_context"; 849 case ParameterABI::SwiftErrorResult: 850 return "swift_error_result"; 851 case ParameterABI::SwiftIndirectResult: 852 return "swift_indirect_result"; 853 } 854 llvm_unreachable("bad parameter ABI kind"); 855} 856 857void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T, 858 raw_ostream &OS) { 859 // If needed for precedence reasons, wrap the inner part in grouping parens. 860 if (!HasEmptyPlaceHolder) 861 OS << ')'; 862 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 863 864 OS << '('; 865 { 866 ParamPolicyRAII ParamPolicy(Policy); 867 for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) { 868 if (i) OS << ", "; 869 870 auto EPI = T->getExtParameterInfo(i); 871 if (EPI.isConsumed()) OS << "__attribute__((ns_consumed)) "; 872 if (EPI.isNoEscape()) 873 OS << "__attribute__((noescape)) "; 874 auto ABI = EPI.getABI(); 875 if (ABI != ParameterABI::Ordinary) 876 OS << "__attribute__((" << getParameterABISpelling(ABI) << ")) "; 877 878 print(T->getParamType(i), OS, StringRef()); 879 } 880 } 881 882 if (T->isVariadic()) { 883 if (T->getNumParams()) 884 OS << ", "; 885 OS << "..."; 886 } else if (T->getNumParams() == 0 && Policy.UseVoidForZeroParams) { 887 // Do not emit int() if we have a proto, emit 'int(void)'. 888 OS << "void"; 889 } 890 891 OS << ')'; 892 893 FunctionType::ExtInfo Info = T->getExtInfo(); 894 895 printFunctionAfter(Info, OS); 896 897 if (!T->getMethodQuals().empty()) 898 OS << " " << T->getMethodQuals().getAsString(); 899 900 switch (T->getRefQualifier()) { 901 case RQ_None: 902 break; 903 904 case RQ_LValue: 905 OS << " &"; 906 break; 907 908 case RQ_RValue: 909 OS << " &&"; 910 break; 911 } 912 T->printExceptionSpecification(OS, Policy); 913 914 if (T->hasTrailingReturn()) { 915 OS << " -> "; 916 print(T->getReturnType(), OS, StringRef()); 917 } else 918 printAfter(T->getReturnType(), OS); 919} 920 921void TypePrinter::printFunctionAfter(const FunctionType::ExtInfo &Info, 922 raw_ostream &OS) { 923 if (!InsideCCAttribute) { 924 switch (Info.getCC()) { 925 case CC_C: 926 // The C calling convention is the default on the vast majority of platforms 927 // we support. If the user wrote it explicitly, it will usually be printed 928 // while traversing the AttributedType. If the type has been desugared, let 929 // the canonical spelling be the implicit calling convention. 930 // FIXME: It would be better to be explicit in certain contexts, such as a 931 // cdecl function typedef used to declare a member function with the 932 // Microsoft C++ ABI. 933 break; 934 case CC_X86StdCall: 935 OS << " __attribute__((stdcall))"; 936 break; 937 case CC_X86FastCall: 938 OS << " __attribute__((fastcall))"; 939 break; 940 case CC_X86ThisCall: 941 OS << " __attribute__((thiscall))"; 942 break; 943 case CC_X86VectorCall: 944 OS << " __attribute__((vectorcall))"; 945 break; 946 case CC_X86Pascal: 947 OS << " __attribute__((pascal))"; 948 break; 949 case CC_AAPCS: 950 OS << " __attribute__((pcs(\"aapcs\")))"; 951 break; 952 case CC_AAPCS_VFP: 953 OS << " __attribute__((pcs(\"aapcs-vfp\")))"; 954 break; 955 case CC_AArch64VectorCall: 956 OS << "__attribute__((aarch64_vector_pcs))"; 957 break; 958 case CC_IntelOclBicc: 959 OS << " __attribute__((intel_ocl_bicc))"; 960 break; 961 case CC_Win64: 962 OS << " __attribute__((ms_abi))"; 963 break; 964 case CC_X86_64SysV: 965 OS << " __attribute__((sysv_abi))"; 966 break; 967 case CC_X86RegCall: 968 OS << " __attribute__((regcall))"; 969 break; 970 case CC_SpirFunction: 971 case CC_OpenCLKernel: 972 // Do nothing. These CCs are not available as attributes. 973 break; 974 case CC_Swift: 975 OS << " __attribute__((swiftcall))"; 976 break; 977 case CC_PreserveMost: 978 OS << " __attribute__((preserve_most))"; 979 break; 980 case CC_PreserveAll: 981 OS << " __attribute__((preserve_all))"; 982 break; 983 } 984 } 985 986 if (Info.getNoReturn()) 987 OS << " __attribute__((noreturn))"; 988 if (Info.getCmseNSCall()) 989 OS << " __attribute__((cmse_nonsecure_call))"; 990 if (Info.getProducesResult()) 991 OS << " __attribute__((ns_returns_retained))"; 992 if (Info.getRegParm()) 993 OS << " __attribute__((regparm (" 994 << Info.getRegParm() << ")))"; 995 if (Info.getNoCallerSavedRegs()) 996 OS << " __attribute__((no_caller_saved_registers))"; 997 if (Info.getNoCfCheck()) 998 OS << " __attribute__((nocf_check))"; 999} 1000 1001void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T, 1002 raw_ostream &OS) { 1003 // If needed for precedence reasons, wrap the inner part in grouping parens. 1004 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false); 1005 printBefore(T->getReturnType(), OS); 1006 if (!PrevPHIsEmpty.get()) 1007 OS << '('; 1008} 1009 1010void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T, 1011 raw_ostream &OS) { 1012 // If needed for precedence reasons, wrap the inner part in grouping parens. 1013 if (!HasEmptyPlaceHolder) 1014 OS << ')'; 1015 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 1016 1017 OS << "()"; 1018 printFunctionAfter(T->getExtInfo(), OS); 1019 printAfter(T->getReturnType(), OS); 1020} 1021 1022void TypePrinter::printTypeSpec(NamedDecl *D, raw_ostream &OS) { 1023 1024 // Compute the full nested-name-specifier for this type. 1025 // In C, this will always be empty except when the type 1026 // being printed is anonymous within other Record. 1027 if (!Policy.SuppressScope) 1028 AppendScope(D->getDeclContext(), OS, D->getDeclName()); 1029 1030 IdentifierInfo *II = D->getIdentifier(); 1031 OS << II->getName(); 1032 spaceBeforePlaceHolder(OS); 1033} 1034 1035void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T, 1036 raw_ostream &OS) { 1037 printTypeSpec(T->getDecl(), OS); 1038} 1039 1040void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T, 1041 raw_ostream &OS) {} 1042 1043void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) { 1044 printTypeSpec(T->getDecl(), OS); 1045} 1046 1047void TypePrinter::printMacroQualifiedBefore(const MacroQualifiedType *T, 1048 raw_ostream &OS) { 1049 StringRef MacroName = T->getMacroIdentifier()->getName(); 1050 OS << MacroName << " "; 1051 1052 // Since this type is meant to print the macro instead of the whole attribute, 1053 // we trim any attributes and go directly to the original modified type. 1054 printBefore(T->getModifiedType(), OS); 1055} 1056 1057void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T, 1058 raw_ostream &OS) { 1059 printAfter(T->getModifiedType(), OS); 1060} 1061 1062void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {} 1063 1064void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T, 1065 raw_ostream &OS) { 1066 OS << "typeof "; 1067 if (T->getUnderlyingExpr()) 1068 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy); 1069 spaceBeforePlaceHolder(OS); 1070} 1071 1072void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T, 1073 raw_ostream &OS) {} 1074 1075void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) { 1076 OS << "typeof("; 1077 print(T->getUnderlyingType(), OS, StringRef()); 1078 OS << ')'; 1079 spaceBeforePlaceHolder(OS); 1080} 1081 1082void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {} 1083 1084void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) { 1085 OS << "decltype("; 1086 if (T->getUnderlyingExpr()) 1087 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy); 1088 OS << ')'; 1089 spaceBeforePlaceHolder(OS); 1090} 1091 1092void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {} 1093 1094void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T, 1095 raw_ostream &OS) { 1096 IncludeStrongLifetimeRAII Strong(Policy); 1097 1098 switch (T->getUTTKind()) { 1099 case UnaryTransformType::EnumUnderlyingType: 1100 OS << "__underlying_type("; 1101 print(T->getBaseType(), OS, StringRef()); 1102 OS << ')'; 1103 spaceBeforePlaceHolder(OS); 1104 return; 1105 } 1106 1107 printBefore(T->getBaseType(), OS); 1108} 1109 1110void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T, 1111 raw_ostream &OS) { 1112 IncludeStrongLifetimeRAII Strong(Policy); 1113 1114 switch (T->getUTTKind()) { 1115 case UnaryTransformType::EnumUnderlyingType: 1116 return; 1117 } 1118 1119 printAfter(T->getBaseType(), OS); 1120} 1121 1122void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) { 1123 // If the type has been deduced, do not print 'auto'. 1124 if (!T->getDeducedType().isNull()) { 1125 printBefore(T->getDeducedType(), OS); 1126 } else { 1127 if (T->isConstrained()) { 1128 // FIXME: Track a TypeConstraint as type sugar, so that we can print the 1129 // type as it was written. 1130 T->getTypeConstraintConcept()->getDeclName().print(OS, Policy); 1131 auto Args = T->getTypeConstraintArguments(); 1132 if (!Args.empty()) 1133 printTemplateArgumentList( 1134 OS, Args, Policy, 1135 T->getTypeConstraintConcept()->getTemplateParameters()); 1136 OS << ' '; 1137 } 1138 switch (T->getKeyword()) { 1139 case AutoTypeKeyword::Auto: OS << "auto"; break; 1140 case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break; 1141 case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break; 1142 } 1143 spaceBeforePlaceHolder(OS); 1144 } 1145} 1146 1147void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) { 1148 // If the type has been deduced, do not print 'auto'. 1149 if (!T->getDeducedType().isNull()) 1150 printAfter(T->getDeducedType(), OS); 1151} 1152 1153void TypePrinter::printDeducedTemplateSpecializationBefore( 1154 const DeducedTemplateSpecializationType *T, raw_ostream &OS) { 1155 // If the type has been deduced, print the deduced type. 1156 if (!T->getDeducedType().isNull()) { 1157 printBefore(T->getDeducedType(), OS); 1158 } else { 1159 IncludeStrongLifetimeRAII Strong(Policy); 1160 T->getTemplateName().print(OS, Policy); 1161 spaceBeforePlaceHolder(OS); 1162 } 1163} 1164 1165void TypePrinter::printDeducedTemplateSpecializationAfter( 1166 const DeducedTemplateSpecializationType *T, raw_ostream &OS) { 1167 // If the type has been deduced, print the deduced type. 1168 if (!T->getDeducedType().isNull()) 1169 printAfter(T->getDeducedType(), OS); 1170} 1171 1172void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) { 1173 IncludeStrongLifetimeRAII Strong(Policy); 1174 1175 OS << "_Atomic("; 1176 print(T->getValueType(), OS, StringRef()); 1177 OS << ')'; 1178 spaceBeforePlaceHolder(OS); 1179} 1180 1181void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {} 1182 1183void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) { 1184 IncludeStrongLifetimeRAII Strong(Policy); 1185 1186 if (T->isReadOnly()) 1187 OS << "read_only "; 1188 else 1189 OS << "write_only "; 1190 OS << "pipe "; 1191 print(T->getElementType(), OS, StringRef()); 1192 spaceBeforePlaceHolder(OS); 1193} 1194 1195void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {} 1196 1197void TypePrinter::printExtIntBefore(const ExtIntType *T, raw_ostream &OS) { 1198 if (T->isUnsigned()) 1199 OS << "unsigned "; 1200 OS << "_ExtInt(" << T->getNumBits() << ")"; 1201 spaceBeforePlaceHolder(OS); 1202} 1203 1204void TypePrinter::printExtIntAfter(const ExtIntType *T, raw_ostream &OS) {} 1205 1206void TypePrinter::printDependentExtIntBefore(const DependentExtIntType *T, 1207 raw_ostream &OS) { 1208 if (T->isUnsigned()) 1209 OS << "unsigned "; 1210 OS << "_ExtInt("; 1211 T->getNumBitsExpr()->printPretty(OS, nullptr, Policy); 1212 OS << ")"; 1213 spaceBeforePlaceHolder(OS); 1214} 1215 1216void TypePrinter::printDependentExtIntAfter(const DependentExtIntType *T, 1217 raw_ostream &OS) {} 1218 1219/// Appends the given scope to the end of a string. 1220void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS, 1221 DeclarationName NameInScope) { 1222 if (DC->isTranslationUnit()) 1223 return; 1224 1225 // FIXME: Consider replacing this with NamedDecl::printNestedNameSpecifier, 1226 // which can also print names for function and method scopes. 1227 if (DC->isFunctionOrMethod()) 1228 return; 1229 1230 if (Policy.Callbacks && Policy.Callbacks->isScopeVisible(DC)) 1231 return; 1232 1233 if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) { 1234 if (Policy.SuppressUnwrittenScope && NS->isAnonymousNamespace()) 1235 return AppendScope(DC->getParent(), OS, NameInScope); 1236 1237 // Only suppress an inline namespace if the name has the same lookup 1238 // results in the enclosing namespace. 1239 if (Policy.SuppressInlineNamespace && NS->isInline() && NameInScope && 1240 NS->isRedundantInlineQualifierFor(NameInScope)) 1241 return AppendScope(DC->getParent(), OS, NameInScope); 1242 1243 AppendScope(DC->getParent(), OS, NS->getDeclName()); 1244 if (NS->getIdentifier()) 1245 OS << NS->getName() << "::"; 1246 else 1247 OS << "(anonymous namespace)::"; 1248 } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) { 1249 AppendScope(DC->getParent(), OS, Spec->getDeclName()); 1250 IncludeStrongLifetimeRAII Strong(Policy); 1251 OS << Spec->getIdentifier()->getName(); 1252 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1253 printTemplateArgumentList( 1254 OS, TemplateArgs.asArray(), Policy, 1255 Spec->getSpecializedTemplate()->getTemplateParameters()); 1256 OS << "::"; 1257 } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) { 1258 AppendScope(DC->getParent(), OS, Tag->getDeclName()); 1259 if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl()) 1260 OS << Typedef->getIdentifier()->getName() << "::"; 1261 else if (Tag->getIdentifier()) 1262 OS << Tag->getIdentifier()->getName() << "::"; 1263 else 1264 return; 1265 } else { 1266 AppendScope(DC->getParent(), OS, NameInScope); 1267 } 1268} 1269 1270void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) { 1271 if (Policy.IncludeTagDefinition) { 1272 PrintingPolicy SubPolicy = Policy; 1273 SubPolicy.IncludeTagDefinition = false; 1274 D->print(OS, SubPolicy, Indentation); 1275 spaceBeforePlaceHolder(OS); 1276 return; 1277 } 1278 1279 bool HasKindDecoration = false; 1280 1281 // We don't print tags unless this is an elaborated type. 1282 // In C, we just assume every RecordType is an elaborated type. 1283 if (!Policy.SuppressTagKeyword && !D->getTypedefNameForAnonDecl()) { 1284 HasKindDecoration = true; 1285 OS << D->getKindName(); 1286 OS << ' '; 1287 } 1288 1289 // Compute the full nested-name-specifier for this type. 1290 // In C, this will always be empty except when the type 1291 // being printed is anonymous within other Record. 1292 if (!Policy.SuppressScope) 1293 AppendScope(D->getDeclContext(), OS, D->getDeclName()); 1294 1295 if (const IdentifierInfo *II = D->getIdentifier()) 1296 OS << II->getName(); 1297 else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) { 1298 assert(Typedef->getIdentifier() && "Typedef without identifier?"); 1299 OS << Typedef->getIdentifier()->getName(); 1300 } else { 1301 // Make an unambiguous representation for anonymous types, e.g. 1302 // (anonymous enum at /usr/include/string.h:120:9) 1303 OS << (Policy.MSVCFormatting ? '`' : '('); 1304 1305 if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) { 1306 OS << "lambda"; 1307 HasKindDecoration = true; 1308 } else if ((isa<RecordDecl>(D) && cast<RecordDecl>(D)->isAnonymousStructOrUnion())) { 1309 OS << "anonymous"; 1310 } else { 1311 OS << "unnamed"; 1312 } 1313 1314 if (Policy.AnonymousTagLocations) { 1315 // Suppress the redundant tag keyword if we just printed one. 1316 // We don't have to worry about ElaboratedTypes here because you can't 1317 // refer to an anonymous type with one. 1318 if (!HasKindDecoration) 1319 OS << " " << D->getKindName(); 1320 1321 PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc( 1322 D->getLocation()); 1323 if (PLoc.isValid()) { 1324 OS << " at "; 1325 StringRef File = PLoc.getFilename(); 1326 if (auto *Callbacks = Policy.Callbacks) 1327 OS << Callbacks->remapPath(File); 1328 else 1329 OS << File; 1330 OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn(); 1331 } 1332 } 1333 1334 OS << (Policy.MSVCFormatting ? '\'' : ')'); 1335 } 1336 1337 // If this is a class template specialization, print the template 1338 // arguments. 1339 if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 1340 ArrayRef<TemplateArgument> Args; 1341 TypeSourceInfo *TAW = Spec->getTypeAsWritten(); 1342 if (!Policy.PrintCanonicalTypes && TAW) { 1343 const TemplateSpecializationType *TST = 1344 cast<TemplateSpecializationType>(TAW->getType()); 1345 Args = TST->template_arguments(); 1346 } else { 1347 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1348 Args = TemplateArgs.asArray(); 1349 } 1350 IncludeStrongLifetimeRAII Strong(Policy); 1351 printTemplateArgumentList( 1352 OS, Args, Policy, 1353 Spec->getSpecializedTemplate()->getTemplateParameters()); 1354 } 1355 1356 spaceBeforePlaceHolder(OS); 1357} 1358 1359void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) { 1360 // Print the preferred name if we have one for this type. 1361 for (const auto *PNA : T->getDecl()->specific_attrs<PreferredNameAttr>()) { 1362 if (declaresSameEntity(PNA->getTypedefType()->getAsCXXRecordDecl(), 1363 T->getDecl())) { 1364 // Find the outermost typedef or alias template. 1365 QualType T = PNA->getTypedefType(); 1366 while (true) { 1367 if (auto *TT = dyn_cast<TypedefType>(T)) 1368 return printTypeSpec(TT->getDecl(), OS); 1369 if (auto *TST = dyn_cast<TemplateSpecializationType>(T)) 1370 return printTemplateId(TST, OS, /*FullyQualify=*/true); 1371 T = T->getLocallyUnqualifiedSingleStepDesugaredType(); 1372 } 1373 } 1374 } 1375 1376 printTag(T->getDecl(), OS); 1377} 1378 1379void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {} 1380 1381void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) { 1382 printTag(T->getDecl(), OS); 1383} 1384 1385void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {} 1386 1387void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T, 1388 raw_ostream &OS) { 1389 TemplateTypeParmDecl *D = T->getDecl(); 1390 if (D && D->isImplicit()) { 1391 if (auto *TC = D->getTypeConstraint()) { 1392 TC->print(OS, Policy); 1393 OS << ' '; 1394 } 1395 OS << "auto"; 1396 } else if (IdentifierInfo *Id = T->getIdentifier()) 1397 OS << Id->getName(); 1398 else 1399 OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex(); 1400 1401 spaceBeforePlaceHolder(OS); 1402} 1403 1404void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T, 1405 raw_ostream &OS) {} 1406 1407void TypePrinter::printSubstTemplateTypeParmBefore( 1408 const SubstTemplateTypeParmType *T, 1409 raw_ostream &OS) { 1410 IncludeStrongLifetimeRAII Strong(Policy); 1411 printBefore(T->getReplacementType(), OS); 1412} 1413 1414void TypePrinter::printSubstTemplateTypeParmAfter( 1415 const SubstTemplateTypeParmType *T, 1416 raw_ostream &OS) { 1417 IncludeStrongLifetimeRAII Strong(Policy); 1418 printAfter(T->getReplacementType(), OS); 1419} 1420 1421void TypePrinter::printSubstTemplateTypeParmPackBefore( 1422 const SubstTemplateTypeParmPackType *T, 1423 raw_ostream &OS) { 1424 IncludeStrongLifetimeRAII Strong(Policy); 1425 printTemplateTypeParmBefore(T->getReplacedParameter(), OS); 1426} 1427 1428void TypePrinter::printSubstTemplateTypeParmPackAfter( 1429 const SubstTemplateTypeParmPackType *T, 1430 raw_ostream &OS) { 1431 IncludeStrongLifetimeRAII Strong(Policy); 1432 printTemplateTypeParmAfter(T->getReplacedParameter(), OS); 1433} 1434 1435void TypePrinter::printTemplateId(const TemplateSpecializationType *T, 1436 raw_ostream &OS, bool FullyQualify) { 1437 IncludeStrongLifetimeRAII Strong(Policy); 1438 1439 TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl(); 1440 if (FullyQualify && TD) { 1441 if (!Policy.SuppressScope) 1442 AppendScope(TD->getDeclContext(), OS, TD->getDeclName()); 1443 1444 IdentifierInfo *II = TD->getIdentifier(); 1445 OS << II->getName(); 1446 } else { 1447 T->getTemplateName().print(OS, Policy); 1448 } 1449 1450 const TemplateParameterList *TPL = TD ? TD->getTemplateParameters() : nullptr; 1451 printTemplateArgumentList(OS, T->template_arguments(), Policy, TPL); 1452 spaceBeforePlaceHolder(OS); 1453} 1454 1455void TypePrinter::printTemplateSpecializationBefore( 1456 const TemplateSpecializationType *T, 1457 raw_ostream &OS) { 1458 printTemplateId(T, OS, false); 1459} 1460 1461void TypePrinter::printTemplateSpecializationAfter( 1462 const TemplateSpecializationType *T, 1463 raw_ostream &OS) {} 1464 1465void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T, 1466 raw_ostream &OS) { 1467 if (Policy.PrintInjectedClassNameWithArguments) 1468 return printTemplateSpecializationBefore(T->getInjectedTST(), OS); 1469 1470 IncludeStrongLifetimeRAII Strong(Policy); 1471 T->getTemplateName().print(OS, Policy); 1472 spaceBeforePlaceHolder(OS); 1473} 1474 1475void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T, 1476 raw_ostream &OS) {} 1477 1478void TypePrinter::printElaboratedBefore(const ElaboratedType *T, 1479 raw_ostream &OS) { 1480 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) { 1481 TagDecl *OwnedTagDecl = T->getOwnedTagDecl(); 1482 assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() && 1483 "OwnedTagDecl expected to be a declaration for the type"); 1484 PrintingPolicy SubPolicy = Policy; 1485 SubPolicy.IncludeTagDefinition = false; 1486 OwnedTagDecl->print(OS, SubPolicy, Indentation); 1487 spaceBeforePlaceHolder(OS); 1488 return; 1489 } 1490 1491 // The tag definition will take care of these. 1492 if (!Policy.IncludeTagDefinition) 1493 { 1494 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1495 if (T->getKeyword() != ETK_None) 1496 OS << " "; 1497 NestedNameSpecifier *Qualifier = T->getQualifier(); 1498 if (Qualifier) 1499 Qualifier->print(OS, Policy); 1500 } 1501 1502 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1503 printBefore(T->getNamedType(), OS); 1504} 1505 1506void TypePrinter::printElaboratedAfter(const ElaboratedType *T, 1507 raw_ostream &OS) { 1508 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) 1509 return; 1510 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1511 printAfter(T->getNamedType(), OS); 1512} 1513 1514void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) { 1515 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1516 printBefore(T->getInnerType(), OS); 1517 OS << '('; 1518 } else 1519 printBefore(T->getInnerType(), OS); 1520} 1521 1522void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) { 1523 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1524 OS << ')'; 1525 printAfter(T->getInnerType(), OS); 1526 } else 1527 printAfter(T->getInnerType(), OS); 1528} 1529 1530void TypePrinter::printDependentNameBefore(const DependentNameType *T, 1531 raw_ostream &OS) { 1532 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1533 if (T->getKeyword() != ETK_None) 1534 OS << " "; 1535 1536 T->getQualifier()->print(OS, Policy); 1537 1538 OS << T->getIdentifier()->getName(); 1539 spaceBeforePlaceHolder(OS); 1540} 1541 1542void TypePrinter::printDependentNameAfter(const DependentNameType *T, 1543 raw_ostream &OS) {} 1544 1545void TypePrinter::printDependentTemplateSpecializationBefore( 1546 const DependentTemplateSpecializationType *T, raw_ostream &OS) { 1547 IncludeStrongLifetimeRAII Strong(Policy); 1548 1549 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1550 if (T->getKeyword() != ETK_None) 1551 OS << " "; 1552 1553 if (T->getQualifier()) 1554 T->getQualifier()->print(OS, Policy); 1555 OS << "template " << T->getIdentifier()->getName(); 1556 printTemplateArgumentList(OS, T->template_arguments(), Policy); 1557 spaceBeforePlaceHolder(OS); 1558} 1559 1560void TypePrinter::printDependentTemplateSpecializationAfter( 1561 const DependentTemplateSpecializationType *T, raw_ostream &OS) {} 1562 1563void TypePrinter::printPackExpansionBefore(const PackExpansionType *T, 1564 raw_ostream &OS) { 1565 printBefore(T->getPattern(), OS); 1566} 1567 1568void TypePrinter::printPackExpansionAfter(const PackExpansionType *T, 1569 raw_ostream &OS) { 1570 printAfter(T->getPattern(), OS); 1571 OS << "..."; 1572} 1573 1574void TypePrinter::printAttributedBefore(const AttributedType *T, 1575 raw_ostream &OS) { 1576 // FIXME: Generate this with TableGen. 1577 1578 // Prefer the macro forms of the GC and ownership qualifiers. 1579 if (T->getAttrKind() == attr::ObjCGC || 1580 T->getAttrKind() == attr::ObjCOwnership) 1581 return printBefore(T->getEquivalentType(), OS); 1582 1583 if (T->getAttrKind() == attr::ObjCKindOf) 1584 OS << "__kindof "; 1585 1586 if (T->getAttrKind() == attr::AddressSpace) 1587 printBefore(T->getEquivalentType(), OS); 1588 else 1589 printBefore(T->getModifiedType(), OS); 1590 1591 if (T->isMSTypeSpec()) { 1592 switch (T->getAttrKind()) { 1593 default: return; 1594 case attr::Ptr32: OS << " __ptr32"; break; 1595 case attr::Ptr64: OS << " __ptr64"; break; 1596 case attr::SPtr: OS << " __sptr"; break; 1597 case attr::UPtr: OS << " __uptr"; break; 1598 } 1599 spaceBeforePlaceHolder(OS); 1600 } 1601 1602 // Print nullability type specifiers. 1603 if (T->getImmediateNullability()) { 1604 if (T->getAttrKind() == attr::TypeNonNull) 1605 OS << " _Nonnull"; 1606 else if (T->getAttrKind() == attr::TypeNullable) 1607 OS << " _Nullable"; 1608 else if (T->getAttrKind() == attr::TypeNullUnspecified) 1609 OS << " _Null_unspecified"; 1610 else if (T->getAttrKind() == attr::TypeNullableResult) 1611 OS << " _Nullable_result"; 1612 else 1613 llvm_unreachable("unhandled nullability"); 1614 spaceBeforePlaceHolder(OS); 1615 } 1616} 1617 1618void TypePrinter::printAttributedAfter(const AttributedType *T, 1619 raw_ostream &OS) { 1620 // FIXME: Generate this with TableGen. 1621 1622 // Prefer the macro forms of the GC and ownership qualifiers. 1623 if (T->getAttrKind() == attr::ObjCGC || 1624 T->getAttrKind() == attr::ObjCOwnership) 1625 return printAfter(T->getEquivalentType(), OS); 1626 1627 // If this is a calling convention attribute, don't print the implicit CC from 1628 // the modified type. 1629 SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv()); 1630 1631 printAfter(T->getModifiedType(), OS); 1632 1633 // Some attributes are printed as qualifiers before the type, so we have 1634 // nothing left to do. 1635 if (T->getAttrKind() == attr::ObjCKindOf || 1636 T->isMSTypeSpec() || T->getImmediateNullability()) 1637 return; 1638 1639 // Don't print the inert __unsafe_unretained attribute at all. 1640 if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained) 1641 return; 1642 1643 // Don't print ns_returns_retained unless it had an effect. 1644 if (T->getAttrKind() == attr::NSReturnsRetained && 1645 !T->getEquivalentType()->castAs<FunctionType>() 1646 ->getExtInfo().getProducesResult()) 1647 return; 1648 1649 if (T->getAttrKind() == attr::LifetimeBound) { 1650 OS << " [[clang::lifetimebound]]"; 1651 return; 1652 } 1653 1654 // The printing of the address_space attribute is handled by the qualifier 1655 // since it is still stored in the qualifier. Return early to prevent printing 1656 // this twice. 1657 if (T->getAttrKind() == attr::AddressSpace) 1658 return; 1659 1660 OS << " __attribute__(("; 1661 switch (T->getAttrKind()) { 1662#define TYPE_ATTR(NAME) 1663#define DECL_OR_TYPE_ATTR(NAME) 1664#define ATTR(NAME) case attr::NAME: 1665#include "clang/Basic/AttrList.inc" 1666 llvm_unreachable("non-type attribute attached to type"); 1667 1668 case attr::OpenCLPrivateAddressSpace: 1669 case attr::OpenCLGlobalAddressSpace: 1670 case attr::OpenCLGlobalDeviceAddressSpace: 1671 case attr::OpenCLGlobalHostAddressSpace: 1672 case attr::OpenCLLocalAddressSpace: 1673 case attr::OpenCLConstantAddressSpace: 1674 case attr::OpenCLGenericAddressSpace: 1675 // FIXME: Update printAttributedBefore to print these once we generate 1676 // AttributedType nodes for them. 1677 break; 1678 1679 case attr::LifetimeBound: 1680 case attr::TypeNonNull: 1681 case attr::TypeNullable: 1682 case attr::TypeNullableResult: 1683 case attr::TypeNullUnspecified: 1684 case attr::ObjCGC: 1685 case attr::ObjCInertUnsafeUnretained: 1686 case attr::ObjCKindOf: 1687 case attr::ObjCOwnership: 1688 case attr::Ptr32: 1689 case attr::Ptr64: 1690 case attr::SPtr: 1691 case attr::UPtr: 1692 case attr::AddressSpace: 1693 case attr::CmseNSCall: 1694 llvm_unreachable("This attribute should have been handled already"); 1695 1696 case attr::NSReturnsRetained: 1697 OS << "ns_returns_retained"; 1698 break; 1699 1700 // FIXME: When Sema learns to form this AttributedType, avoid printing the 1701 // attribute again in printFunctionProtoAfter. 1702 case attr::AnyX86NoCfCheck: OS << "nocf_check"; break; 1703 case attr::CDecl: OS << "cdecl"; break; 1704 case attr::FastCall: OS << "fastcall"; break; 1705 case attr::StdCall: OS << "stdcall"; break; 1706 case attr::ThisCall: OS << "thiscall"; break; 1707 case attr::SwiftCall: OS << "swiftcall"; break; 1708 case attr::VectorCall: OS << "vectorcall"; break; 1709 case attr::Pascal: OS << "pascal"; break; 1710 case attr::MSABI: OS << "ms_abi"; break; 1711 case attr::SysVABI: OS << "sysv_abi"; break; 1712 case attr::RegCall: OS << "regcall"; break; 1713 case attr::Pcs: { 1714 OS << "pcs("; 1715 QualType t = T->getEquivalentType(); 1716 while (!t->isFunctionType()) 1717 t = t->getPointeeType(); 1718 OS << (t->castAs<FunctionType>()->getCallConv() == CC_AAPCS ? 1719 "\"aapcs\"" : "\"aapcs-vfp\""); 1720 OS << ')'; 1721 break; 1722 } 1723 case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break; 1724 case attr::IntelOclBicc: OS << "inteloclbicc"; break; 1725 case attr::PreserveMost: 1726 OS << "preserve_most"; 1727 break; 1728 1729 case attr::PreserveAll: 1730 OS << "preserve_all"; 1731 break; 1732 case attr::NoDeref: 1733 OS << "noderef"; 1734 break; 1735 case attr::AcquireHandle: 1736 OS << "acquire_handle"; 1737 break; 1738 case attr::ArmMveStrictPolymorphism: 1739 OS << "__clang_arm_mve_strict_polymorphism"; 1740 break; 1741 } 1742 OS << "))"; 1743} 1744 1745void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T, 1746 raw_ostream &OS) { 1747 OS << T->getDecl()->getName(); 1748 spaceBeforePlaceHolder(OS); 1749} 1750 1751void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T, 1752 raw_ostream &OS) {} 1753 1754void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T, 1755 raw_ostream &OS) { 1756 OS << T->getDecl()->getName(); 1757 if (!T->qual_empty()) { 1758 bool isFirst = true; 1759 OS << '<'; 1760 for (const auto *I : T->quals()) { 1761 if (isFirst) 1762 isFirst = false; 1763 else 1764 OS << ','; 1765 OS << I->getName(); 1766 } 1767 OS << '>'; 1768 } 1769 1770 spaceBeforePlaceHolder(OS); 1771} 1772 1773void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T, 1774 raw_ostream &OS) {} 1775 1776void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T, 1777 raw_ostream &OS) { 1778 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1779 !T->isKindOfTypeAsWritten()) 1780 return printBefore(T->getBaseType(), OS); 1781 1782 if (T->isKindOfTypeAsWritten()) 1783 OS << "__kindof "; 1784 1785 print(T->getBaseType(), OS, StringRef()); 1786 1787 if (T->isSpecializedAsWritten()) { 1788 bool isFirst = true; 1789 OS << '<'; 1790 for (auto typeArg : T->getTypeArgsAsWritten()) { 1791 if (isFirst) 1792 isFirst = false; 1793 else 1794 OS << ","; 1795 1796 print(typeArg, OS, StringRef()); 1797 } 1798 OS << '>'; 1799 } 1800 1801 if (!T->qual_empty()) { 1802 bool isFirst = true; 1803 OS << '<'; 1804 for (const auto *I : T->quals()) { 1805 if (isFirst) 1806 isFirst = false; 1807 else 1808 OS << ','; 1809 OS << I->getName(); 1810 } 1811 OS << '>'; 1812 } 1813 1814 spaceBeforePlaceHolder(OS); 1815} 1816 1817void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T, 1818 raw_ostream &OS) { 1819 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1820 !T->isKindOfTypeAsWritten()) 1821 return printAfter(T->getBaseType(), OS); 1822} 1823 1824void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T, 1825 raw_ostream &OS) { 1826 printBefore(T->getPointeeType(), OS); 1827 1828 // If we need to print the pointer, print it now. 1829 if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() && 1830 !T->isObjCClassType() && !T->isObjCQualifiedClassType()) { 1831 if (HasEmptyPlaceHolder) 1832 OS << ' '; 1833 OS << '*'; 1834 } 1835} 1836 1837void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T, 1838 raw_ostream &OS) {} 1839 1840static 1841const TemplateArgument &getArgument(const TemplateArgument &A) { return A; } 1842 1843static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) { 1844 return A.getArgument(); 1845} 1846 1847static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP, 1848 llvm::raw_ostream &OS, bool IncludeType) { 1849 A.print(PP, OS, IncludeType); 1850} 1851 1852static void printArgument(const TemplateArgumentLoc &A, 1853 const PrintingPolicy &PP, llvm::raw_ostream &OS, 1854 bool IncludeType) { 1855 const TemplateArgument::ArgKind &Kind = A.getArgument().getKind(); 1856 if (Kind == TemplateArgument::ArgKind::Type) 1857 return A.getTypeSourceInfo()->getType().print(OS, PP); 1858 return A.getArgument().print(PP, OS, IncludeType); 1859} 1860 1861static bool isSubstitutedTemplateArgument(ASTContext &Ctx, TemplateArgument Arg, 1862 TemplateArgument Pattern, 1863 ArrayRef<TemplateArgument> Args, 1864 unsigned Depth); 1865 1866static bool isSubstitutedType(ASTContext &Ctx, QualType T, QualType Pattern, 1867 ArrayRef<TemplateArgument> Args, unsigned Depth) { 1868 if (Ctx.hasSameType(T, Pattern)) 1869 return true; 1870 1871 // A type parameter matches its argument. 1872 if (auto *TTPT = Pattern->getAs<TemplateTypeParmType>()) { 1873 if (TTPT->getDepth() == Depth && TTPT->getIndex() < Args.size() && 1874 Args[TTPT->getIndex()].getKind() == TemplateArgument::Type) { 1875 QualType SubstArg = Ctx.getQualifiedType( 1876 Args[TTPT->getIndex()].getAsType(), Pattern.getQualifiers()); 1877 return Ctx.hasSameType(SubstArg, T); 1878 } 1879 return false; 1880 } 1881 1882 // FIXME: Recurse into array types. 1883 1884 // All other cases will need the types to be identically qualified. 1885 Qualifiers TQual, PatQual; 1886 T = Ctx.getUnqualifiedArrayType(T, TQual); 1887 Pattern = Ctx.getUnqualifiedArrayType(Pattern, PatQual); 1888 if (TQual != PatQual) 1889 return false; 1890 1891 // Recurse into pointer-like types. 1892 { 1893 QualType TPointee = T->getPointeeType(); 1894 QualType PPointee = Pattern->getPointeeType(); 1895 if (!TPointee.isNull() && !PPointee.isNull()) 1896 return T->getTypeClass() == Pattern->getTypeClass() && 1897 isSubstitutedType(Ctx, TPointee, PPointee, Args, Depth); 1898 } 1899 1900 // Recurse into template specialization types. 1901 if (auto *PTST = 1902 Pattern.getCanonicalType()->getAs<TemplateSpecializationType>()) { 1903 TemplateName Template; 1904 ArrayRef<TemplateArgument> TemplateArgs; 1905 if (auto *TTST = T->getAs<TemplateSpecializationType>()) { 1906 Template = TTST->getTemplateName(); 1907 TemplateArgs = TTST->template_arguments(); 1908 } else if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>( 1909 T->getAsCXXRecordDecl())) { 1910 Template = TemplateName(CTSD->getSpecializedTemplate()); 1911 TemplateArgs = CTSD->getTemplateArgs().asArray(); 1912 } else { 1913 return false; 1914 } 1915 1916 if (!isSubstitutedTemplateArgument(Ctx, Template, PTST->getTemplateName(), 1917 Args, Depth)) 1918 return false; 1919 if (TemplateArgs.size() != PTST->getNumArgs()) 1920 return false; 1921 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 1922 if (!isSubstitutedTemplateArgument(Ctx, TemplateArgs[I], PTST->getArg(I), 1923 Args, Depth)) 1924 return false; 1925 return true; 1926 } 1927 1928 // FIXME: Handle more cases. 1929 return false; 1930} 1931 1932static bool isSubstitutedTemplateArgument(ASTContext &Ctx, TemplateArgument Arg, 1933 TemplateArgument Pattern, 1934 ArrayRef<TemplateArgument> Args, 1935 unsigned Depth) { 1936 Arg = Ctx.getCanonicalTemplateArgument(Arg); 1937 Pattern = Ctx.getCanonicalTemplateArgument(Pattern); 1938 if (Arg.structurallyEquals(Pattern)) 1939 return true; 1940 1941 if (Pattern.getKind() == TemplateArgument::Expression) { 1942 if (auto *DRE = 1943 dyn_cast<DeclRefExpr>(Pattern.getAsExpr()->IgnoreParenImpCasts())) { 1944 if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl())) 1945 return NTTP->getDepth() == Depth && Args.size() > NTTP->getIndex() && 1946 Args[NTTP->getIndex()].structurallyEquals(Arg); 1947 } 1948 } 1949 1950 if (Arg.getKind() != Pattern.getKind()) 1951 return false; 1952 1953 if (Arg.getKind() == TemplateArgument::Type) 1954 return isSubstitutedType(Ctx, Arg.getAsType(), Pattern.getAsType(), Args, 1955 Depth); 1956 1957 if (Arg.getKind() == TemplateArgument::Template) { 1958 TemplateDecl *PatTD = Pattern.getAsTemplate().getAsTemplateDecl(); 1959 if (auto *TTPD = dyn_cast_or_null<TemplateTemplateParmDecl>(PatTD)) 1960 return TTPD->getDepth() == Depth && Args.size() > TTPD->getIndex() && 1961 Ctx.getCanonicalTemplateArgument(Args[TTPD->getIndex()]) 1962 .structurallyEquals(Arg); 1963 } 1964 1965 // FIXME: Handle more cases. 1966 return false; 1967} 1968 1969/// Make a best-effort determination of whether the type T can be produced by 1970/// substituting Args into the default argument of Param. 1971static bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg, 1972 const NamedDecl *Param, 1973 ArrayRef<TemplateArgument> Args, 1974 unsigned Depth) { 1975 // An empty pack is equivalent to not providing a pack argument. 1976 if (Arg.getKind() == TemplateArgument::Pack && Arg.pack_size() == 0) 1977 return true; 1978 1979 if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Param)) { 1980 return TTPD->hasDefaultArgument() && 1981 isSubstitutedTemplateArgument(Ctx, Arg, TTPD->getDefaultArgument(), 1982 Args, Depth); 1983 } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Param)) { 1984 return TTPD->hasDefaultArgument() && 1985 isSubstitutedTemplateArgument( 1986 Ctx, Arg, TTPD->getDefaultArgument().getArgument(), Args, Depth); 1987 } else if (auto *NTTPD = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 1988 return NTTPD->hasDefaultArgument() && 1989 isSubstitutedTemplateArgument(Ctx, Arg, NTTPD->getDefaultArgument(), 1990 Args, Depth); 1991 } 1992 return false; 1993} 1994 1995template <typename TA> 1996static void printTo(raw_ostream &OS, ArrayRef<TA> Args, 1997 const PrintingPolicy &Policy, bool SkipBrackets, 1998 const TemplateParameterList *TPL, bool IsPack, 1999 unsigned ParmIndex) { 2000 // Drop trailing template arguments that match default arguments. 2001 if (TPL && Policy.SuppressDefaultTemplateArgs && 2002 !Policy.PrintCanonicalTypes && !Args.empty() && !IsPack && 2003 Args.size() <= TPL->size()) { 2004 ASTContext &Ctx = TPL->getParam(0)->getASTContext(); 2005 llvm::SmallVector<TemplateArgument, 8> OrigArgs; 2006 for (const TA &A : Args) 2007 OrigArgs.push_back(getArgument(A)); 2008 while (!Args.empty() && 2009 isSubstitutedDefaultArgument(Ctx, getArgument(Args.back()), 2010 TPL->getParam(Args.size() - 1), 2011 OrigArgs, TPL->getDepth())) 2012 Args = Args.drop_back(); 2013 } 2014 2015 const char *Comma = Policy.MSVCFormatting ? "," : ", "; 2016 if (!SkipBrackets) 2017 OS << '<'; 2018 2019 bool NeedSpace = false; 2020 bool FirstArg = true; 2021 for (const auto &Arg : Args) { 2022 // Print the argument into a string. 2023 SmallString<128> Buf; 2024 llvm::raw_svector_ostream ArgOS(Buf); 2025 const TemplateArgument &Argument = getArgument(Arg); 2026 if (Argument.getKind() == TemplateArgument::Pack) { 2027 if (Argument.pack_size() && !FirstArg) 2028 OS << Comma; 2029 printTo(ArgOS, Argument.getPackAsArray(), Policy, true, TPL, 2030 /*IsPack*/ true, ParmIndex); 2031 } else { 2032 if (!FirstArg) 2033 OS << Comma; 2034 // Tries to print the argument with location info if exists. 2035 printArgument( 2036 Arg, Policy, ArgOS, 2037 TemplateParameterList::shouldIncludeTypeForArgument(TPL, ParmIndex)); 2038 } 2039 StringRef ArgString = ArgOS.str(); 2040 2041 // If this is the first argument and its string representation 2042 // begins with the global scope specifier ('::foo'), add a space 2043 // to avoid printing the diagraph '<:'. 2044 if (FirstArg && !ArgString.empty() && ArgString[0] == ':') 2045 OS << ' '; 2046 2047 OS << ArgString; 2048 2049 // If the last character of our string is '>', add another space to 2050 // keep the two '>''s separate tokens. 2051 NeedSpace = Policy.SplitTemplateClosers && !ArgString.empty() && 2052 ArgString.back() == '>'; 2053 FirstArg = false; 2054 2055 // Use same template parameter for all elements of Pack 2056 if (!IsPack) 2057 ParmIndex++; 2058 } 2059 2060 if (NeedSpace) 2061 OS << ' '; 2062 2063 if (!SkipBrackets) 2064 OS << '>'; 2065} 2066 2067void clang::printTemplateArgumentList(raw_ostream &OS, 2068 const TemplateArgumentListInfo &Args, 2069 const PrintingPolicy &Policy, 2070 const TemplateParameterList *TPL) { 2071 printTemplateArgumentList(OS, Args.arguments(), Policy, TPL); 2072} 2073 2074void clang::printTemplateArgumentList(raw_ostream &OS, 2075 ArrayRef<TemplateArgument> Args, 2076 const PrintingPolicy &Policy, 2077 const TemplateParameterList *TPL) { 2078 printTo(OS, Args, Policy, false, TPL, /*isPack*/ false, /*parmIndex*/ 0); 2079} 2080 2081void clang::printTemplateArgumentList(raw_ostream &OS, 2082 ArrayRef<TemplateArgumentLoc> Args, 2083 const PrintingPolicy &Policy, 2084 const TemplateParameterList *TPL) { 2085 printTo(OS, Args, Policy, false, TPL, /*isPack*/ false, /*parmIndex*/ 0); 2086} 2087 2088std::string Qualifiers::getAsString() const { 2089 LangOptions LO; 2090 return getAsString(PrintingPolicy(LO)); 2091} 2092 2093// Appends qualifiers to the given string, separated by spaces. Will 2094// prefix a space if the string is non-empty. Will not append a final 2095// space. 2096std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const { 2097 SmallString<64> Buf; 2098 llvm::raw_svector_ostream StrOS(Buf); 2099 print(StrOS, Policy); 2100 return std::string(StrOS.str()); 2101} 2102 2103bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const { 2104 if (getCVRQualifiers()) 2105 return false; 2106 2107 if (getAddressSpace() != LangAS::Default) 2108 return false; 2109 2110 if (getObjCGCAttr()) 2111 return false; 2112 2113 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) 2114 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)) 2115 return false; 2116 2117 return true; 2118} 2119 2120std::string Qualifiers::getAddrSpaceAsString(LangAS AS) { 2121 switch (AS) { 2122 case LangAS::Default: 2123 return ""; 2124 case LangAS::opencl_global: 2125 case LangAS::sycl_global: 2126 return "__global"; 2127 case LangAS::opencl_local: 2128 case LangAS::sycl_local: 2129 return "__local"; 2130 case LangAS::opencl_private: 2131 case LangAS::sycl_private: 2132 return "__private"; 2133 case LangAS::opencl_constant: 2134 return "__constant"; 2135 case LangAS::opencl_generic: 2136 return "__generic"; 2137 case LangAS::opencl_global_device: 2138 case LangAS::sycl_global_device: 2139 return "__global_device"; 2140 case LangAS::opencl_global_host: 2141 case LangAS::sycl_global_host: 2142 return "__global_host"; 2143 case LangAS::cuda_device: 2144 return "__device__"; 2145 case LangAS::cuda_constant: 2146 return "__constant__"; 2147 case LangAS::cuda_shared: 2148 return "__shared__"; 2149 case LangAS::ptr32_sptr: 2150 return "__sptr __ptr32"; 2151 case LangAS::ptr32_uptr: 2152 return "__uptr __ptr32"; 2153 case LangAS::ptr64: 2154 return "__ptr64"; 2155 default: 2156 return std::to_string(toTargetAddressSpace(AS)); 2157 } 2158} 2159 2160// Appends qualifiers to the given string, separated by spaces. Will 2161// prefix a space if the string is non-empty. Will not append a final 2162// space. 2163void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy, 2164 bool appendSpaceIfNonEmpty) const { 2165 bool addSpace = false; 2166 2167 unsigned quals = getCVRQualifiers(); 2168 if (quals) { 2169 AppendTypeQualList(OS, quals, Policy.Restrict); 2170 addSpace = true; 2171 } 2172 if (hasUnaligned()) { 2173 if (addSpace) 2174 OS << ' '; 2175 OS << "__unaligned"; 2176 addSpace = true; 2177 } 2178 auto ASStr = getAddrSpaceAsString(getAddressSpace()); 2179 if (!ASStr.empty()) { 2180 if (addSpace) 2181 OS << ' '; 2182 addSpace = true; 2183 // Wrap target address space into an attribute syntax 2184 if (isTargetAddressSpace(getAddressSpace())) 2185 OS << "__attribute__((address_space(" << ASStr << ")))"; 2186 else 2187 OS << ASStr; 2188 } 2189 2190 if (Qualifiers::GC gc = getObjCGCAttr()) { 2191 if (addSpace) 2192 OS << ' '; 2193 addSpace = true; 2194 if (gc == Qualifiers::Weak) 2195 OS << "__weak"; 2196 else 2197 OS << "__strong"; 2198 } 2199 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) { 2200 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){ 2201 if (addSpace) 2202 OS << ' '; 2203 addSpace = true; 2204 } 2205 2206 switch (lifetime) { 2207 case Qualifiers::OCL_None: llvm_unreachable("none but true"); 2208 case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break; 2209 case Qualifiers::OCL_Strong: 2210 if (!Policy.SuppressStrongLifetime) 2211 OS << "__strong"; 2212 break; 2213 2214 case Qualifiers::OCL_Weak: OS << "__weak"; break; 2215 case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break; 2216 } 2217 } 2218 2219 if (appendSpaceIfNonEmpty && addSpace) 2220 OS << ' '; 2221} 2222 2223std::string QualType::getAsString() const { 2224 return getAsString(split(), LangOptions()); 2225} 2226 2227std::string QualType::getAsString(const PrintingPolicy &Policy) const { 2228 std::string S; 2229 getAsStringInternal(S, Policy); 2230 return S; 2231} 2232 2233std::string QualType::getAsString(const Type *ty, Qualifiers qs, 2234 const PrintingPolicy &Policy) { 2235 std::string buffer; 2236 getAsStringInternal(ty, qs, buffer, Policy); 2237 return buffer; 2238} 2239 2240void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy, 2241 const Twine &PlaceHolder, unsigned Indentation) const { 2242 print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder, 2243 Indentation); 2244} 2245 2246void QualType::print(const Type *ty, Qualifiers qs, 2247 raw_ostream &OS, const PrintingPolicy &policy, 2248 const Twine &PlaceHolder, unsigned Indentation) { 2249 SmallString<128> PHBuf; 2250 StringRef PH = PlaceHolder.toStringRef(PHBuf); 2251 2252 TypePrinter(policy, Indentation).print(ty, qs, OS, PH); 2253} 2254 2255void QualType::getAsStringInternal(std::string &Str, 2256 const PrintingPolicy &Policy) const { 2257 return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str, 2258 Policy); 2259} 2260 2261void QualType::getAsStringInternal(const Type *ty, Qualifiers qs, 2262 std::string &buffer, 2263 const PrintingPolicy &policy) { 2264 SmallString<256> Buf; 2265 llvm::raw_svector_ostream StrOS(Buf); 2266 TypePrinter(policy).print(ty, qs, StrOS, buffer); 2267 std::string str = std::string(StrOS.str()); 2268 buffer.swap(str); 2269} 2270