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 46 using namespace clang; 47 48 namespace { 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 141 static 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 163 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) { 164 if (!HasEmptyPlaceHolder) 165 OS << ' '; 166 } 167 168 static SplitQualType splitAccordingToPolicy(QualType QT, 169 const PrintingPolicy &Policy) { 170 if (Policy.PrintCanonicalTypes) 171 QT = QT.getCanonicalType(); 172 return QT.split(); 173 } 174 175 void 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 180 void 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 194 bool 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 285 void 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 ". 299 void 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 345 void 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]". 352 void 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 362 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) { 363 OS << T->getName(Policy); 364 spaceBeforePlaceHolder(OS); 365 } 366 367 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {} 368 369 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) { 370 OS << "_Complex "; 371 printBefore(T->getElementType(), OS); 372 } 373 374 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) { 375 printAfter(T->getElementType(), OS); 376 } 377 378 void 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 389 void 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 399 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T, 400 raw_ostream &OS) { 401 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 402 printBefore(T->getPointeeType(), OS); 403 OS << '^'; 404 } 405 406 void 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. 414 static QualType skipTopLevelReferences(QualType T) { 415 if (auto *Ref = T->getAs<ReferenceType>()) 416 return skipTopLevelReferences(Ref->getPointeeTypeAsWritten()); 417 return T; 418 } 419 420 void 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 433 void 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 445 void 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 458 void 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 470 void 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 487 void 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 498 void 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 505 void 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 521 void 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 528 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T, 529 raw_ostream &OS) { 530 OS << "[]"; 531 printAfter(T->getElementType(), OS); 532 } 533 534 void 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 541 void 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 561 void 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 567 void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) { 568 printAfter(T->getAdjustedType(), OS); 569 } 570 571 void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) { 572 // Print as though it's a pointer. 573 printAdjustedBefore(T, OS); 574 } 575 576 void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) { 577 printAdjustedAfter(T, OS); 578 } 579 580 void 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 588 void 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 598 void TypePrinter::printDependentAddressSpaceBefore( 599 const DependentAddressSpaceType *T, raw_ostream &OS) { 600 printBefore(T->getPointeeType(), OS); 601 } 602 603 void 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 612 void TypePrinter::printDependentSizedExtVectorBefore( 613 const DependentSizedExtVectorType *T, 614 raw_ostream &OS) { 615 printBefore(T->getElementType(), OS); 616 } 617 618 void 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 628 void 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 683 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) { 684 printAfter(T->getElementType(), OS); 685 } 686 687 void 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 748 void TypePrinter::printDependentVectorAfter( 749 const DependentVectorType *T, raw_ostream &OS) { 750 printAfter(T->getElementType(), OS); 751 } 752 753 void TypePrinter::printExtVectorBefore(const ExtVectorType *T, 754 raw_ostream &OS) { 755 printBefore(T->getElementType(), OS); 756 } 757 758 void 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 765 void 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 773 void TypePrinter::printConstantMatrixAfter(const ConstantMatrixType *T, 774 raw_ostream &OS) { 775 printAfter(T->getElementType(), OS); 776 } 777 778 void 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 792 void TypePrinter::printDependentSizedMatrixAfter( 793 const DependentSizedMatrixType *T, raw_ostream &OS) { 794 printAfter(T->getElementType(), OS); 795 } 796 797 void 798 FunctionProtoType::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 828 void 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 843 StringRef 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 857 void 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 921 void 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 1001 void 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 1010 void 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 1022 void 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 1035 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T, 1036 raw_ostream &OS) { 1037 printTypeSpec(T->getDecl(), OS); 1038 } 1039 1040 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T, 1041 raw_ostream &OS) {} 1042 1043 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) { 1044 printTypeSpec(T->getDecl(), OS); 1045 } 1046 1047 void 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 1057 void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T, 1058 raw_ostream &OS) { 1059 printAfter(T->getModifiedType(), OS); 1060 } 1061 1062 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {} 1063 1064 void 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 1072 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T, 1073 raw_ostream &OS) {} 1074 1075 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) { 1076 OS << "typeof("; 1077 print(T->getUnderlyingType(), OS, StringRef()); 1078 OS << ')'; 1079 spaceBeforePlaceHolder(OS); 1080 } 1081 1082 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {} 1083 1084 void 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 1092 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {} 1093 1094 void 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 1110 void 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 1122 void 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 OS << T->getTypeConstraintConcept()->getName(); 1129 auto Args = T->getTypeConstraintArguments(); 1130 if (!Args.empty()) 1131 printTemplateArgumentList( 1132 OS, Args, Policy, 1133 T->getTypeConstraintConcept()->getTemplateParameters()); 1134 OS << ' '; 1135 } 1136 switch (T->getKeyword()) { 1137 case AutoTypeKeyword::Auto: OS << "auto"; break; 1138 case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break; 1139 case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break; 1140 } 1141 spaceBeforePlaceHolder(OS); 1142 } 1143 } 1144 1145 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) { 1146 // If the type has been deduced, do not print 'auto'. 1147 if (!T->getDeducedType().isNull()) 1148 printAfter(T->getDeducedType(), OS); 1149 } 1150 1151 void TypePrinter::printDeducedTemplateSpecializationBefore( 1152 const DeducedTemplateSpecializationType *T, raw_ostream &OS) { 1153 // If the type has been deduced, print the deduced type. 1154 if (!T->getDeducedType().isNull()) { 1155 printBefore(T->getDeducedType(), OS); 1156 } else { 1157 IncludeStrongLifetimeRAII Strong(Policy); 1158 T->getTemplateName().print(OS, Policy); 1159 spaceBeforePlaceHolder(OS); 1160 } 1161 } 1162 1163 void TypePrinter::printDeducedTemplateSpecializationAfter( 1164 const DeducedTemplateSpecializationType *T, raw_ostream &OS) { 1165 // If the type has been deduced, print the deduced type. 1166 if (!T->getDeducedType().isNull()) 1167 printAfter(T->getDeducedType(), OS); 1168 } 1169 1170 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) { 1171 IncludeStrongLifetimeRAII Strong(Policy); 1172 1173 OS << "_Atomic("; 1174 print(T->getValueType(), OS, StringRef()); 1175 OS << ')'; 1176 spaceBeforePlaceHolder(OS); 1177 } 1178 1179 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {} 1180 1181 void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) { 1182 IncludeStrongLifetimeRAII Strong(Policy); 1183 1184 if (T->isReadOnly()) 1185 OS << "read_only "; 1186 else 1187 OS << "write_only "; 1188 OS << "pipe "; 1189 print(T->getElementType(), OS, StringRef()); 1190 spaceBeforePlaceHolder(OS); 1191 } 1192 1193 void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {} 1194 1195 void TypePrinter::printExtIntBefore(const ExtIntType *T, raw_ostream &OS) { 1196 if (T->isUnsigned()) 1197 OS << "unsigned "; 1198 OS << "_ExtInt(" << T->getNumBits() << ")"; 1199 spaceBeforePlaceHolder(OS); 1200 } 1201 1202 void TypePrinter::printExtIntAfter(const ExtIntType *T, raw_ostream &OS) {} 1203 1204 void TypePrinter::printDependentExtIntBefore(const DependentExtIntType *T, 1205 raw_ostream &OS) { 1206 if (T->isUnsigned()) 1207 OS << "unsigned "; 1208 OS << "_ExtInt("; 1209 T->getNumBitsExpr()->printPretty(OS, nullptr, Policy); 1210 OS << ")"; 1211 spaceBeforePlaceHolder(OS); 1212 } 1213 1214 void TypePrinter::printDependentExtIntAfter(const DependentExtIntType *T, 1215 raw_ostream &OS) {} 1216 1217 /// Appends the given scope to the end of a string. 1218 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS, 1219 DeclarationName NameInScope) { 1220 if (DC->isTranslationUnit()) 1221 return; 1222 1223 // FIXME: Consider replacing this with NamedDecl::printNestedNameSpecifier, 1224 // which can also print names for function and method scopes. 1225 if (DC->isFunctionOrMethod()) 1226 return; 1227 1228 if (Policy.Callbacks && Policy.Callbacks->isScopeVisible(DC)) 1229 return; 1230 1231 if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) { 1232 if (Policy.SuppressUnwrittenScope && NS->isAnonymousNamespace()) 1233 return AppendScope(DC->getParent(), OS, NameInScope); 1234 1235 // Only suppress an inline namespace if the name has the same lookup 1236 // results in the enclosing namespace. 1237 if (Policy.SuppressInlineNamespace && NS->isInline() && NameInScope && 1238 DC->getParent()->lookup(NameInScope).size() == 1239 DC->lookup(NameInScope).size()) 1240 return AppendScope(DC->getParent(), OS, NameInScope); 1241 1242 AppendScope(DC->getParent(), OS, NS->getDeclName()); 1243 if (NS->getIdentifier()) 1244 OS << NS->getName() << "::"; 1245 else 1246 OS << "(anonymous namespace)::"; 1247 } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) { 1248 AppendScope(DC->getParent(), OS, Spec->getDeclName()); 1249 IncludeStrongLifetimeRAII Strong(Policy); 1250 OS << Spec->getIdentifier()->getName(); 1251 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1252 printTemplateArgumentList( 1253 OS, TemplateArgs.asArray(), Policy, 1254 Spec->getSpecializedTemplate()->getTemplateParameters()); 1255 OS << "::"; 1256 } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) { 1257 AppendScope(DC->getParent(), OS, Tag->getDeclName()); 1258 if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl()) 1259 OS << Typedef->getIdentifier()->getName() << "::"; 1260 else if (Tag->getIdentifier()) 1261 OS << Tag->getIdentifier()->getName() << "::"; 1262 else 1263 return; 1264 } else { 1265 AppendScope(DC->getParent(), OS, NameInScope); 1266 } 1267 } 1268 1269 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) { 1270 if (Policy.IncludeTagDefinition) { 1271 PrintingPolicy SubPolicy = Policy; 1272 SubPolicy.IncludeTagDefinition = false; 1273 D->print(OS, SubPolicy, Indentation); 1274 spaceBeforePlaceHolder(OS); 1275 return; 1276 } 1277 1278 bool HasKindDecoration = false; 1279 1280 // We don't print tags unless this is an elaborated type. 1281 // In C, we just assume every RecordType is an elaborated type. 1282 if (!Policy.SuppressTagKeyword && !D->getTypedefNameForAnonDecl()) { 1283 HasKindDecoration = true; 1284 OS << D->getKindName(); 1285 OS << ' '; 1286 } 1287 1288 // Compute the full nested-name-specifier for this type. 1289 // In C, this will always be empty except when the type 1290 // being printed is anonymous within other Record. 1291 if (!Policy.SuppressScope) 1292 AppendScope(D->getDeclContext(), OS, D->getDeclName()); 1293 1294 if (const IdentifierInfo *II = D->getIdentifier()) 1295 OS << II->getName(); 1296 else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) { 1297 assert(Typedef->getIdentifier() && "Typedef without identifier?"); 1298 OS << Typedef->getIdentifier()->getName(); 1299 } else { 1300 // Make an unambiguous representation for anonymous types, e.g. 1301 // (anonymous enum at /usr/include/string.h:120:9) 1302 OS << (Policy.MSVCFormatting ? '`' : '('); 1303 1304 if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) { 1305 OS << "lambda"; 1306 HasKindDecoration = true; 1307 } else { 1308 OS << "anonymous"; 1309 } 1310 1311 if (Policy.AnonymousTagLocations) { 1312 // Suppress the redundant tag keyword if we just printed one. 1313 // We don't have to worry about ElaboratedTypes here because you can't 1314 // refer to an anonymous type with one. 1315 if (!HasKindDecoration) 1316 OS << " " << D->getKindName(); 1317 1318 PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc( 1319 D->getLocation()); 1320 if (PLoc.isValid()) { 1321 OS << " at "; 1322 StringRef File = PLoc.getFilename(); 1323 if (auto *Callbacks = Policy.Callbacks) 1324 OS << Callbacks->remapPath(File); 1325 else 1326 OS << File; 1327 OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn(); 1328 } 1329 } 1330 1331 OS << (Policy.MSVCFormatting ? '\'' : ')'); 1332 } 1333 1334 // If this is a class template specialization, print the template 1335 // arguments. 1336 if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 1337 ArrayRef<TemplateArgument> Args; 1338 TypeSourceInfo *TAW = Spec->getTypeAsWritten(); 1339 if (!Policy.PrintCanonicalTypes && TAW) { 1340 const TemplateSpecializationType *TST = 1341 cast<TemplateSpecializationType>(TAW->getType()); 1342 Args = TST->template_arguments(); 1343 } else { 1344 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1345 Args = TemplateArgs.asArray(); 1346 } 1347 IncludeStrongLifetimeRAII Strong(Policy); 1348 printTemplateArgumentList( 1349 OS, Args, Policy, 1350 Spec->getSpecializedTemplate()->getTemplateParameters()); 1351 } 1352 1353 spaceBeforePlaceHolder(OS); 1354 } 1355 1356 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) { 1357 // Print the preferred name if we have one for this type. 1358 for (const auto *PNA : T->getDecl()->specific_attrs<PreferredNameAttr>()) { 1359 if (declaresSameEntity(PNA->getTypedefType()->getAsCXXRecordDecl(), 1360 T->getDecl())) { 1361 // Find the outermost typedef or alias template. 1362 QualType T = PNA->getTypedefType(); 1363 while (true) { 1364 if (auto *TT = dyn_cast<TypedefType>(T)) 1365 return printTypeSpec(TT->getDecl(), OS); 1366 if (auto *TST = dyn_cast<TemplateSpecializationType>(T)) 1367 return printTemplateId(TST, OS, /*FullyQualify=*/true); 1368 T = T->getLocallyUnqualifiedSingleStepDesugaredType(); 1369 } 1370 } 1371 } 1372 1373 printTag(T->getDecl(), OS); 1374 } 1375 1376 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {} 1377 1378 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) { 1379 printTag(T->getDecl(), OS); 1380 } 1381 1382 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {} 1383 1384 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T, 1385 raw_ostream &OS) { 1386 TemplateTypeParmDecl *D = T->getDecl(); 1387 if (D && D->isImplicit()) { 1388 if (auto *TC = D->getTypeConstraint()) { 1389 TC->print(OS, Policy); 1390 OS << ' '; 1391 } 1392 OS << "auto"; 1393 } else if (IdentifierInfo *Id = T->getIdentifier()) 1394 OS << Id->getName(); 1395 else 1396 OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex(); 1397 1398 spaceBeforePlaceHolder(OS); 1399 } 1400 1401 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T, 1402 raw_ostream &OS) {} 1403 1404 void TypePrinter::printSubstTemplateTypeParmBefore( 1405 const SubstTemplateTypeParmType *T, 1406 raw_ostream &OS) { 1407 IncludeStrongLifetimeRAII Strong(Policy); 1408 printBefore(T->getReplacementType(), OS); 1409 } 1410 1411 void TypePrinter::printSubstTemplateTypeParmAfter( 1412 const SubstTemplateTypeParmType *T, 1413 raw_ostream &OS) { 1414 IncludeStrongLifetimeRAII Strong(Policy); 1415 printAfter(T->getReplacementType(), OS); 1416 } 1417 1418 void TypePrinter::printSubstTemplateTypeParmPackBefore( 1419 const SubstTemplateTypeParmPackType *T, 1420 raw_ostream &OS) { 1421 IncludeStrongLifetimeRAII Strong(Policy); 1422 printTemplateTypeParmBefore(T->getReplacedParameter(), OS); 1423 } 1424 1425 void TypePrinter::printSubstTemplateTypeParmPackAfter( 1426 const SubstTemplateTypeParmPackType *T, 1427 raw_ostream &OS) { 1428 IncludeStrongLifetimeRAII Strong(Policy); 1429 printTemplateTypeParmAfter(T->getReplacedParameter(), OS); 1430 } 1431 1432 void TypePrinter::printTemplateId(const TemplateSpecializationType *T, 1433 raw_ostream &OS, bool FullyQualify) { 1434 IncludeStrongLifetimeRAII Strong(Policy); 1435 1436 TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl(); 1437 if (FullyQualify && TD) { 1438 if (!Policy.SuppressScope) 1439 AppendScope(TD->getDeclContext(), OS, TD->getDeclName()); 1440 1441 IdentifierInfo *II = TD->getIdentifier(); 1442 OS << II->getName(); 1443 } else { 1444 T->getTemplateName().print(OS, Policy); 1445 } 1446 1447 const TemplateParameterList *TPL = TD ? TD->getTemplateParameters() : nullptr; 1448 printTemplateArgumentList(OS, T->template_arguments(), Policy, TPL); 1449 spaceBeforePlaceHolder(OS); 1450 } 1451 1452 void TypePrinter::printTemplateSpecializationBefore( 1453 const TemplateSpecializationType *T, 1454 raw_ostream &OS) { 1455 printTemplateId(T, OS, false); 1456 } 1457 1458 void TypePrinter::printTemplateSpecializationAfter( 1459 const TemplateSpecializationType *T, 1460 raw_ostream &OS) {} 1461 1462 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T, 1463 raw_ostream &OS) { 1464 if (Policy.PrintInjectedClassNameWithArguments) 1465 return printTemplateSpecializationBefore(T->getInjectedTST(), OS); 1466 1467 IncludeStrongLifetimeRAII Strong(Policy); 1468 T->getTemplateName().print(OS, Policy); 1469 spaceBeforePlaceHolder(OS); 1470 } 1471 1472 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T, 1473 raw_ostream &OS) {} 1474 1475 void TypePrinter::printElaboratedBefore(const ElaboratedType *T, 1476 raw_ostream &OS) { 1477 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) { 1478 TagDecl *OwnedTagDecl = T->getOwnedTagDecl(); 1479 assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() && 1480 "OwnedTagDecl expected to be a declaration for the type"); 1481 PrintingPolicy SubPolicy = Policy; 1482 SubPolicy.IncludeTagDefinition = false; 1483 OwnedTagDecl->print(OS, SubPolicy, Indentation); 1484 spaceBeforePlaceHolder(OS); 1485 return; 1486 } 1487 1488 // The tag definition will take care of these. 1489 if (!Policy.IncludeTagDefinition) 1490 { 1491 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1492 if (T->getKeyword() != ETK_None) 1493 OS << " "; 1494 NestedNameSpecifier *Qualifier = T->getQualifier(); 1495 if (Qualifier) 1496 Qualifier->print(OS, Policy); 1497 } 1498 1499 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1500 printBefore(T->getNamedType(), OS); 1501 } 1502 1503 void TypePrinter::printElaboratedAfter(const ElaboratedType *T, 1504 raw_ostream &OS) { 1505 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) 1506 return; 1507 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1508 printAfter(T->getNamedType(), OS); 1509 } 1510 1511 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) { 1512 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1513 printBefore(T->getInnerType(), OS); 1514 OS << '('; 1515 } else 1516 printBefore(T->getInnerType(), OS); 1517 } 1518 1519 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) { 1520 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1521 OS << ')'; 1522 printAfter(T->getInnerType(), OS); 1523 } else 1524 printAfter(T->getInnerType(), OS); 1525 } 1526 1527 void TypePrinter::printDependentNameBefore(const DependentNameType *T, 1528 raw_ostream &OS) { 1529 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1530 if (T->getKeyword() != ETK_None) 1531 OS << " "; 1532 1533 T->getQualifier()->print(OS, Policy); 1534 1535 OS << T->getIdentifier()->getName(); 1536 spaceBeforePlaceHolder(OS); 1537 } 1538 1539 void TypePrinter::printDependentNameAfter(const DependentNameType *T, 1540 raw_ostream &OS) {} 1541 1542 void TypePrinter::printDependentTemplateSpecializationBefore( 1543 const DependentTemplateSpecializationType *T, raw_ostream &OS) { 1544 IncludeStrongLifetimeRAII Strong(Policy); 1545 1546 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1547 if (T->getKeyword() != ETK_None) 1548 OS << " "; 1549 1550 if (T->getQualifier()) 1551 T->getQualifier()->print(OS, Policy); 1552 OS << "template " << T->getIdentifier()->getName(); 1553 printTemplateArgumentList(OS, T->template_arguments(), Policy); 1554 spaceBeforePlaceHolder(OS); 1555 } 1556 1557 void TypePrinter::printDependentTemplateSpecializationAfter( 1558 const DependentTemplateSpecializationType *T, raw_ostream &OS) {} 1559 1560 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T, 1561 raw_ostream &OS) { 1562 printBefore(T->getPattern(), OS); 1563 } 1564 1565 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T, 1566 raw_ostream &OS) { 1567 printAfter(T->getPattern(), OS); 1568 OS << "..."; 1569 } 1570 1571 void TypePrinter::printAttributedBefore(const AttributedType *T, 1572 raw_ostream &OS) { 1573 // FIXME: Generate this with TableGen. 1574 1575 // Prefer the macro forms of the GC and ownership qualifiers. 1576 if (T->getAttrKind() == attr::ObjCGC || 1577 T->getAttrKind() == attr::ObjCOwnership) 1578 return printBefore(T->getEquivalentType(), OS); 1579 1580 if (T->getAttrKind() == attr::ObjCKindOf) 1581 OS << "__kindof "; 1582 1583 if (T->getAttrKind() == attr::AddressSpace) 1584 printBefore(T->getEquivalentType(), OS); 1585 else 1586 printBefore(T->getModifiedType(), OS); 1587 1588 if (T->isMSTypeSpec()) { 1589 switch (T->getAttrKind()) { 1590 default: return; 1591 case attr::Ptr32: OS << " __ptr32"; break; 1592 case attr::Ptr64: OS << " __ptr64"; break; 1593 case attr::SPtr: OS << " __sptr"; break; 1594 case attr::UPtr: OS << " __uptr"; break; 1595 } 1596 spaceBeforePlaceHolder(OS); 1597 } 1598 1599 // Print nullability type specifiers. 1600 if (T->getImmediateNullability()) { 1601 if (T->getAttrKind() == attr::TypeNonNull) 1602 OS << " _Nonnull"; 1603 else if (T->getAttrKind() == attr::TypeNullable) 1604 OS << " _Nullable"; 1605 else if (T->getAttrKind() == attr::TypeNullUnspecified) 1606 OS << " _Null_unspecified"; 1607 else if (T->getAttrKind() == attr::TypeNullableResult) 1608 OS << " _Nullable_result"; 1609 else 1610 llvm_unreachable("unhandled nullability"); 1611 spaceBeforePlaceHolder(OS); 1612 } 1613 } 1614 1615 void TypePrinter::printAttributedAfter(const AttributedType *T, 1616 raw_ostream &OS) { 1617 // FIXME: Generate this with TableGen. 1618 1619 // Prefer the macro forms of the GC and ownership qualifiers. 1620 if (T->getAttrKind() == attr::ObjCGC || 1621 T->getAttrKind() == attr::ObjCOwnership) 1622 return printAfter(T->getEquivalentType(), OS); 1623 1624 // If this is a calling convention attribute, don't print the implicit CC from 1625 // the modified type. 1626 SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv()); 1627 1628 printAfter(T->getModifiedType(), OS); 1629 1630 // Some attributes are printed as qualifiers before the type, so we have 1631 // nothing left to do. 1632 if (T->getAttrKind() == attr::ObjCKindOf || 1633 T->isMSTypeSpec() || T->getImmediateNullability()) 1634 return; 1635 1636 // Don't print the inert __unsafe_unretained attribute at all. 1637 if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained) 1638 return; 1639 1640 // Don't print ns_returns_retained unless it had an effect. 1641 if (T->getAttrKind() == attr::NSReturnsRetained && 1642 !T->getEquivalentType()->castAs<FunctionType>() 1643 ->getExtInfo().getProducesResult()) 1644 return; 1645 1646 if (T->getAttrKind() == attr::LifetimeBound) { 1647 OS << " [[clang::lifetimebound]]"; 1648 return; 1649 } 1650 1651 // The printing of the address_space attribute is handled by the qualifier 1652 // since it is still stored in the qualifier. Return early to prevent printing 1653 // this twice. 1654 if (T->getAttrKind() == attr::AddressSpace) 1655 return; 1656 1657 OS << " __attribute__(("; 1658 switch (T->getAttrKind()) { 1659 #define TYPE_ATTR(NAME) 1660 #define DECL_OR_TYPE_ATTR(NAME) 1661 #define ATTR(NAME) case attr::NAME: 1662 #include "clang/Basic/AttrList.inc" 1663 llvm_unreachable("non-type attribute attached to type"); 1664 1665 case attr::OpenCLPrivateAddressSpace: 1666 case attr::OpenCLGlobalAddressSpace: 1667 case attr::OpenCLGlobalDeviceAddressSpace: 1668 case attr::OpenCLGlobalHostAddressSpace: 1669 case attr::OpenCLLocalAddressSpace: 1670 case attr::OpenCLConstantAddressSpace: 1671 case attr::OpenCLGenericAddressSpace: 1672 // FIXME: Update printAttributedBefore to print these once we generate 1673 // AttributedType nodes for them. 1674 break; 1675 1676 case attr::LifetimeBound: 1677 case attr::TypeNonNull: 1678 case attr::TypeNullable: 1679 case attr::TypeNullableResult: 1680 case attr::TypeNullUnspecified: 1681 case attr::ObjCGC: 1682 case attr::ObjCInertUnsafeUnretained: 1683 case attr::ObjCKindOf: 1684 case attr::ObjCOwnership: 1685 case attr::Ptr32: 1686 case attr::Ptr64: 1687 case attr::SPtr: 1688 case attr::UPtr: 1689 case attr::AddressSpace: 1690 case attr::CmseNSCall: 1691 llvm_unreachable("This attribute should have been handled already"); 1692 1693 case attr::NSReturnsRetained: 1694 OS << "ns_returns_retained"; 1695 break; 1696 1697 // FIXME: When Sema learns to form this AttributedType, avoid printing the 1698 // attribute again in printFunctionProtoAfter. 1699 case attr::AnyX86NoCfCheck: OS << "nocf_check"; break; 1700 case attr::CDecl: OS << "cdecl"; break; 1701 case attr::FastCall: OS << "fastcall"; break; 1702 case attr::StdCall: OS << "stdcall"; break; 1703 case attr::ThisCall: OS << "thiscall"; break; 1704 case attr::SwiftCall: OS << "swiftcall"; break; 1705 case attr::VectorCall: OS << "vectorcall"; break; 1706 case attr::Pascal: OS << "pascal"; break; 1707 case attr::MSABI: OS << "ms_abi"; break; 1708 case attr::SysVABI: OS << "sysv_abi"; break; 1709 case attr::RegCall: OS << "regcall"; break; 1710 case attr::Pcs: { 1711 OS << "pcs("; 1712 QualType t = T->getEquivalentType(); 1713 while (!t->isFunctionType()) 1714 t = t->getPointeeType(); 1715 OS << (t->castAs<FunctionType>()->getCallConv() == CC_AAPCS ? 1716 "\"aapcs\"" : "\"aapcs-vfp\""); 1717 OS << ')'; 1718 break; 1719 } 1720 case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break; 1721 case attr::IntelOclBicc: OS << "inteloclbicc"; break; 1722 case attr::PreserveMost: 1723 OS << "preserve_most"; 1724 break; 1725 1726 case attr::PreserveAll: 1727 OS << "preserve_all"; 1728 break; 1729 case attr::NoDeref: 1730 OS << "noderef"; 1731 break; 1732 case attr::AcquireHandle: 1733 OS << "acquire_handle"; 1734 break; 1735 case attr::ArmMveStrictPolymorphism: 1736 OS << "__clang_arm_mve_strict_polymorphism"; 1737 break; 1738 } 1739 OS << "))"; 1740 } 1741 1742 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T, 1743 raw_ostream &OS) { 1744 OS << T->getDecl()->getName(); 1745 spaceBeforePlaceHolder(OS); 1746 } 1747 1748 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T, 1749 raw_ostream &OS) {} 1750 1751 void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T, 1752 raw_ostream &OS) { 1753 OS << T->getDecl()->getName(); 1754 if (!T->qual_empty()) { 1755 bool isFirst = true; 1756 OS << '<'; 1757 for (const auto *I : T->quals()) { 1758 if (isFirst) 1759 isFirst = false; 1760 else 1761 OS << ','; 1762 OS << I->getName(); 1763 } 1764 OS << '>'; 1765 } 1766 1767 spaceBeforePlaceHolder(OS); 1768 } 1769 1770 void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T, 1771 raw_ostream &OS) {} 1772 1773 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T, 1774 raw_ostream &OS) { 1775 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1776 !T->isKindOfTypeAsWritten()) 1777 return printBefore(T->getBaseType(), OS); 1778 1779 if (T->isKindOfTypeAsWritten()) 1780 OS << "__kindof "; 1781 1782 print(T->getBaseType(), OS, StringRef()); 1783 1784 if (T->isSpecializedAsWritten()) { 1785 bool isFirst = true; 1786 OS << '<'; 1787 for (auto typeArg : T->getTypeArgsAsWritten()) { 1788 if (isFirst) 1789 isFirst = false; 1790 else 1791 OS << ","; 1792 1793 print(typeArg, OS, StringRef()); 1794 } 1795 OS << '>'; 1796 } 1797 1798 if (!T->qual_empty()) { 1799 bool isFirst = true; 1800 OS << '<'; 1801 for (const auto *I : T->quals()) { 1802 if (isFirst) 1803 isFirst = false; 1804 else 1805 OS << ','; 1806 OS << I->getName(); 1807 } 1808 OS << '>'; 1809 } 1810 1811 spaceBeforePlaceHolder(OS); 1812 } 1813 1814 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T, 1815 raw_ostream &OS) { 1816 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1817 !T->isKindOfTypeAsWritten()) 1818 return printAfter(T->getBaseType(), OS); 1819 } 1820 1821 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T, 1822 raw_ostream &OS) { 1823 printBefore(T->getPointeeType(), OS); 1824 1825 // If we need to print the pointer, print it now. 1826 if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() && 1827 !T->isObjCClassType() && !T->isObjCQualifiedClassType()) { 1828 if (HasEmptyPlaceHolder) 1829 OS << ' '; 1830 OS << '*'; 1831 } 1832 } 1833 1834 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T, 1835 raw_ostream &OS) {} 1836 1837 static 1838 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; } 1839 1840 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) { 1841 return A.getArgument(); 1842 } 1843 1844 static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP, 1845 llvm::raw_ostream &OS) { 1846 A.print(PP, OS); 1847 } 1848 1849 static void printArgument(const TemplateArgumentLoc &A, 1850 const PrintingPolicy &PP, llvm::raw_ostream &OS) { 1851 const TemplateArgument::ArgKind &Kind = A.getArgument().getKind(); 1852 if (Kind == TemplateArgument::ArgKind::Type) 1853 return A.getTypeSourceInfo()->getType().print(OS, PP); 1854 return A.getArgument().print(PP, OS); 1855 } 1856 1857 static bool isSubstitutedTemplateArgument(ASTContext &Ctx, TemplateArgument Arg, 1858 TemplateArgument Pattern, 1859 ArrayRef<TemplateArgument> Args, 1860 unsigned Depth); 1861 1862 static bool isSubstitutedType(ASTContext &Ctx, QualType T, QualType Pattern, 1863 ArrayRef<TemplateArgument> Args, unsigned Depth) { 1864 if (Ctx.hasSameType(T, Pattern)) 1865 return true; 1866 1867 // A type parameter matches its argument. 1868 if (auto *TTPT = Pattern->getAs<TemplateTypeParmType>()) { 1869 if (TTPT->getDepth() == Depth && TTPT->getIndex() < Args.size() && 1870 Args[TTPT->getIndex()].getKind() == TemplateArgument::Type) { 1871 QualType SubstArg = Ctx.getQualifiedType( 1872 Args[TTPT->getIndex()].getAsType(), Pattern.getQualifiers()); 1873 return Ctx.hasSameType(SubstArg, T); 1874 } 1875 return false; 1876 } 1877 1878 // FIXME: Recurse into array types. 1879 1880 // All other cases will need the types to be identically qualified. 1881 Qualifiers TQual, PatQual; 1882 T = Ctx.getUnqualifiedArrayType(T, TQual); 1883 Pattern = Ctx.getUnqualifiedArrayType(Pattern, PatQual); 1884 if (TQual != PatQual) 1885 return false; 1886 1887 // Recurse into pointer-like types. 1888 { 1889 QualType TPointee = T->getPointeeType(); 1890 QualType PPointee = Pattern->getPointeeType(); 1891 if (!TPointee.isNull() && !PPointee.isNull()) 1892 return T->getTypeClass() == Pattern->getTypeClass() && 1893 isSubstitutedType(Ctx, TPointee, PPointee, Args, Depth); 1894 } 1895 1896 // Recurse into template specialization types. 1897 if (auto *PTST = 1898 Pattern.getCanonicalType()->getAs<TemplateSpecializationType>()) { 1899 TemplateName Template; 1900 ArrayRef<TemplateArgument> TemplateArgs; 1901 if (auto *TTST = T->getAs<TemplateSpecializationType>()) { 1902 Template = TTST->getTemplateName(); 1903 TemplateArgs = TTST->template_arguments(); 1904 } else if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>( 1905 T->getAsCXXRecordDecl())) { 1906 Template = TemplateName(CTSD->getSpecializedTemplate()); 1907 TemplateArgs = CTSD->getTemplateArgs().asArray(); 1908 } else { 1909 return false; 1910 } 1911 1912 if (!isSubstitutedTemplateArgument(Ctx, Template, PTST->getTemplateName(), 1913 Args, Depth)) 1914 return false; 1915 if (TemplateArgs.size() != PTST->getNumArgs()) 1916 return false; 1917 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 1918 if (!isSubstitutedTemplateArgument(Ctx, TemplateArgs[I], PTST->getArg(I), 1919 Args, Depth)) 1920 return false; 1921 return true; 1922 } 1923 1924 // FIXME: Handle more cases. 1925 return false; 1926 } 1927 1928 static bool isSubstitutedTemplateArgument(ASTContext &Ctx, TemplateArgument Arg, 1929 TemplateArgument Pattern, 1930 ArrayRef<TemplateArgument> Args, 1931 unsigned Depth) { 1932 Arg = Ctx.getCanonicalTemplateArgument(Arg); 1933 Pattern = Ctx.getCanonicalTemplateArgument(Pattern); 1934 if (Arg.structurallyEquals(Pattern)) 1935 return true; 1936 1937 if (Pattern.getKind() == TemplateArgument::Expression) { 1938 if (auto *DRE = 1939 dyn_cast<DeclRefExpr>(Pattern.getAsExpr()->IgnoreParenImpCasts())) { 1940 if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl())) 1941 return NTTP->getDepth() == Depth && Args.size() > NTTP->getIndex() && 1942 Args[NTTP->getIndex()].structurallyEquals(Arg); 1943 } 1944 } 1945 1946 if (Arg.getKind() != Pattern.getKind()) 1947 return false; 1948 1949 if (Arg.getKind() == TemplateArgument::Type) 1950 return isSubstitutedType(Ctx, Arg.getAsType(), Pattern.getAsType(), Args, 1951 Depth); 1952 1953 if (Arg.getKind() == TemplateArgument::Template) { 1954 TemplateDecl *PatTD = Pattern.getAsTemplate().getAsTemplateDecl(); 1955 if (auto *TTPD = dyn_cast_or_null<TemplateTemplateParmDecl>(PatTD)) 1956 return TTPD->getDepth() == Depth && Args.size() > TTPD->getIndex() && 1957 Ctx.getCanonicalTemplateArgument(Args[TTPD->getIndex()]) 1958 .structurallyEquals(Arg); 1959 } 1960 1961 // FIXME: Handle more cases. 1962 return false; 1963 } 1964 1965 /// Make a best-effort determination of whether the type T can be produced by 1966 /// substituting Args into the default argument of Param. 1967 static bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg, 1968 const NamedDecl *Param, 1969 ArrayRef<TemplateArgument> Args, 1970 unsigned Depth) { 1971 // An empty pack is equivalent to not providing a pack argument. 1972 if (Arg.getKind() == TemplateArgument::Pack && Arg.pack_size() == 0) 1973 return true; 1974 1975 if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Param)) { 1976 return TTPD->hasDefaultArgument() && 1977 isSubstitutedTemplateArgument(Ctx, Arg, TTPD->getDefaultArgument(), 1978 Args, Depth); 1979 } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Param)) { 1980 return TTPD->hasDefaultArgument() && 1981 isSubstitutedTemplateArgument( 1982 Ctx, Arg, TTPD->getDefaultArgument().getArgument(), Args, Depth); 1983 } else if (auto *NTTPD = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 1984 return NTTPD->hasDefaultArgument() && 1985 isSubstitutedTemplateArgument(Ctx, Arg, NTTPD->getDefaultArgument(), 1986 Args, Depth); 1987 } 1988 return false; 1989 } 1990 1991 template<typename TA> 1992 static void printTo(raw_ostream &OS, ArrayRef<TA> Args, 1993 const PrintingPolicy &Policy, bool SkipBrackets, 1994 const TemplateParameterList *TPL) { 1995 // Drop trailing template arguments that match default arguments. 1996 if (TPL && Policy.SuppressDefaultTemplateArgs && 1997 !Policy.PrintCanonicalTypes && !Args.empty() && 1998 Args.size() <= TPL->size()) { 1999 ASTContext &Ctx = TPL->getParam(0)->getASTContext(); 2000 llvm::SmallVector<TemplateArgument, 8> OrigArgs; 2001 for (const TA &A : Args) 2002 OrigArgs.push_back(getArgument(A)); 2003 while (!Args.empty() && 2004 isSubstitutedDefaultArgument(Ctx, getArgument(Args.back()), 2005 TPL->getParam(Args.size() - 1), 2006 OrigArgs, TPL->getDepth())) 2007 Args = Args.drop_back(); 2008 } 2009 2010 const char *Comma = Policy.MSVCFormatting ? "," : ", "; 2011 if (!SkipBrackets) 2012 OS << '<'; 2013 2014 bool NeedSpace = false; 2015 bool FirstArg = true; 2016 for (const auto &Arg : Args) { 2017 // Print the argument into a string. 2018 SmallString<128> Buf; 2019 llvm::raw_svector_ostream ArgOS(Buf); 2020 const TemplateArgument &Argument = getArgument(Arg); 2021 if (Argument.getKind() == TemplateArgument::Pack) { 2022 if (Argument.pack_size() && !FirstArg) 2023 OS << Comma; 2024 printTo(ArgOS, Argument.getPackAsArray(), Policy, true, nullptr); 2025 } else { 2026 if (!FirstArg) 2027 OS << Comma; 2028 // Tries to print the argument with location info if exists. 2029 printArgument(Arg, Policy, ArgOS); 2030 } 2031 StringRef ArgString = ArgOS.str(); 2032 2033 // If this is the first argument and its string representation 2034 // begins with the global scope specifier ('::foo'), add a space 2035 // to avoid printing the diagraph '<:'. 2036 if (FirstArg && !ArgString.empty() && ArgString[0] == ':') 2037 OS << ' '; 2038 2039 OS << ArgString; 2040 2041 // If the last character of our string is '>', add another space to 2042 // keep the two '>''s separate tokens. 2043 NeedSpace = Policy.SplitTemplateClosers && !ArgString.empty() && 2044 ArgString.back() == '>'; 2045 FirstArg = false; 2046 } 2047 2048 if (NeedSpace) 2049 OS << ' '; 2050 2051 if (!SkipBrackets) 2052 OS << '>'; 2053 } 2054 2055 void clang::printTemplateArgumentList(raw_ostream &OS, 2056 const TemplateArgumentListInfo &Args, 2057 const PrintingPolicy &Policy, 2058 const TemplateParameterList *TPL) { 2059 printTemplateArgumentList(OS, Args.arguments(), Policy, TPL); 2060 } 2061 2062 void clang::printTemplateArgumentList(raw_ostream &OS, 2063 ArrayRef<TemplateArgument> Args, 2064 const PrintingPolicy &Policy, 2065 const TemplateParameterList *TPL) { 2066 printTo(OS, Args, Policy, false, TPL); 2067 } 2068 2069 void clang::printTemplateArgumentList(raw_ostream &OS, 2070 ArrayRef<TemplateArgumentLoc> Args, 2071 const PrintingPolicy &Policy, 2072 const TemplateParameterList *TPL) { 2073 printTo(OS, Args, Policy, false, TPL); 2074 } 2075 2076 std::string Qualifiers::getAsString() const { 2077 LangOptions LO; 2078 return getAsString(PrintingPolicy(LO)); 2079 } 2080 2081 // Appends qualifiers to the given string, separated by spaces. Will 2082 // prefix a space if the string is non-empty. Will not append a final 2083 // space. 2084 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const { 2085 SmallString<64> Buf; 2086 llvm::raw_svector_ostream StrOS(Buf); 2087 print(StrOS, Policy); 2088 return std::string(StrOS.str()); 2089 } 2090 2091 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const { 2092 if (getCVRQualifiers()) 2093 return false; 2094 2095 if (getAddressSpace() != LangAS::Default) 2096 return false; 2097 2098 if (getObjCGCAttr()) 2099 return false; 2100 2101 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) 2102 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)) 2103 return false; 2104 2105 return true; 2106 } 2107 2108 std::string Qualifiers::getAddrSpaceAsString(LangAS AS) { 2109 switch (AS) { 2110 case LangAS::Default: 2111 return ""; 2112 case LangAS::opencl_global: 2113 return "__global"; 2114 case LangAS::opencl_local: 2115 return "__local"; 2116 case LangAS::opencl_private: 2117 return "__private"; 2118 case LangAS::opencl_constant: 2119 return "__constant"; 2120 case LangAS::opencl_generic: 2121 return "__generic"; 2122 case LangAS::opencl_global_device: 2123 return "__global_device"; 2124 case LangAS::opencl_global_host: 2125 return "__global_host"; 2126 case LangAS::cuda_device: 2127 return "__device__"; 2128 case LangAS::cuda_constant: 2129 return "__constant__"; 2130 case LangAS::cuda_shared: 2131 return "__shared__"; 2132 case LangAS::ptr32_sptr: 2133 return "__sptr __ptr32"; 2134 case LangAS::ptr32_uptr: 2135 return "__uptr __ptr32"; 2136 case LangAS::ptr64: 2137 return "__ptr64"; 2138 default: 2139 return std::to_string(toTargetAddressSpace(AS)); 2140 } 2141 } 2142 2143 // Appends qualifiers to the given string, separated by spaces. Will 2144 // prefix a space if the string is non-empty. Will not append a final 2145 // space. 2146 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy, 2147 bool appendSpaceIfNonEmpty) const { 2148 bool addSpace = false; 2149 2150 unsigned quals = getCVRQualifiers(); 2151 if (quals) { 2152 AppendTypeQualList(OS, quals, Policy.Restrict); 2153 addSpace = true; 2154 } 2155 if (hasUnaligned()) { 2156 if (addSpace) 2157 OS << ' '; 2158 OS << "__unaligned"; 2159 addSpace = true; 2160 } 2161 auto ASStr = getAddrSpaceAsString(getAddressSpace()); 2162 if (!ASStr.empty()) { 2163 if (addSpace) 2164 OS << ' '; 2165 addSpace = true; 2166 // Wrap target address space into an attribute syntax 2167 if (isTargetAddressSpace(getAddressSpace())) 2168 OS << "__attribute__((address_space(" << ASStr << ")))"; 2169 else 2170 OS << ASStr; 2171 } 2172 2173 if (Qualifiers::GC gc = getObjCGCAttr()) { 2174 if (addSpace) 2175 OS << ' '; 2176 addSpace = true; 2177 if (gc == Qualifiers::Weak) 2178 OS << "__weak"; 2179 else 2180 OS << "__strong"; 2181 } 2182 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) { 2183 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){ 2184 if (addSpace) 2185 OS << ' '; 2186 addSpace = true; 2187 } 2188 2189 switch (lifetime) { 2190 case Qualifiers::OCL_None: llvm_unreachable("none but true"); 2191 case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break; 2192 case Qualifiers::OCL_Strong: 2193 if (!Policy.SuppressStrongLifetime) 2194 OS << "__strong"; 2195 break; 2196 2197 case Qualifiers::OCL_Weak: OS << "__weak"; break; 2198 case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break; 2199 } 2200 } 2201 2202 if (appendSpaceIfNonEmpty && addSpace) 2203 OS << ' '; 2204 } 2205 2206 std::string QualType::getAsString() const { 2207 return getAsString(split(), LangOptions()); 2208 } 2209 2210 std::string QualType::getAsString(const PrintingPolicy &Policy) const { 2211 std::string S; 2212 getAsStringInternal(S, Policy); 2213 return S; 2214 } 2215 2216 std::string QualType::getAsString(const Type *ty, Qualifiers qs, 2217 const PrintingPolicy &Policy) { 2218 std::string buffer; 2219 getAsStringInternal(ty, qs, buffer, Policy); 2220 return buffer; 2221 } 2222 2223 void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy, 2224 const Twine &PlaceHolder, unsigned Indentation) const { 2225 print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder, 2226 Indentation); 2227 } 2228 2229 void QualType::print(const Type *ty, Qualifiers qs, 2230 raw_ostream &OS, const PrintingPolicy &policy, 2231 const Twine &PlaceHolder, unsigned Indentation) { 2232 SmallString<128> PHBuf; 2233 StringRef PH = PlaceHolder.toStringRef(PHBuf); 2234 2235 TypePrinter(policy, Indentation).print(ty, qs, OS, PH); 2236 } 2237 2238 void QualType::getAsStringInternal(std::string &Str, 2239 const PrintingPolicy &Policy) const { 2240 return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str, 2241 Policy); 2242 } 2243 2244 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs, 2245 std::string &buffer, 2246 const PrintingPolicy &policy) { 2247 SmallString<256> Buf; 2248 llvm::raw_svector_ostream StrOS(Buf); 2249 TypePrinter(policy).print(ty, qs, StrOS, buffer); 2250 std::string str = std::string(StrOS.str()); 2251 buffer.swap(str); 2252 } 2253