1 //===- DeclarationName.h - Representation of declaration names --*- C++ -*-===// 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 file declares the DeclarationName and DeclarationNameTable classes. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_AST_DECLARATIONNAME_H 14 #define LLVM_CLANG_AST_DECLARATIONNAME_H 15 16 #include "clang/AST/Type.h" 17 #include "clang/Basic/Diagnostic.h" 18 #include "clang/Basic/IdentifierTable.h" 19 #include "clang/Basic/OperatorKinds.h" 20 #include "clang/Basic/PartialDiagnostic.h" 21 #include "clang/Basic/SourceLocation.h" 22 #include "llvm/ADT/DenseMapInfo.h" 23 #include "llvm/ADT/FoldingSet.h" 24 #include "llvm/ADT/STLExtras.h" 25 #include "llvm/Support/Compiler.h" 26 #include "llvm/Support/type_traits.h" 27 #include <cassert> 28 #include <cstdint> 29 #include <cstring> 30 #include <string> 31 32 namespace clang { 33 34 class ASTContext; 35 template <typename> class CanQual; 36 class DeclarationName; 37 class DeclarationNameTable; 38 struct PrintingPolicy; 39 class TemplateDecl; 40 class TypeSourceInfo; 41 42 using CanQualType = CanQual<Type>; 43 44 namespace detail { 45 46 /// CXXSpecialNameExtra records the type associated with one of the "special" 47 /// kinds of declaration names in C++, e.g., constructors, destructors, and 48 /// conversion functions. Note that CXXSpecialName is used for C++ constructor, 49 /// destructor and conversion functions, but the actual kind is not stored in 50 /// CXXSpecialName. Instead we use three different FoldingSet<CXXSpecialName> 51 /// in DeclarationNameTable. 52 class alignas(IdentifierInfoAlignment) CXXSpecialNameExtra 53 : public llvm::FoldingSetNode { 54 friend class clang::DeclarationName; 55 friend class clang::DeclarationNameTable; 56 57 /// The type associated with this declaration name. 58 QualType Type; 59 60 /// Extra information associated with this declaration name that 61 /// can be used by the front end. All bits are really needed 62 /// so it is not possible to stash something in the low order bits. 63 void *FETokenInfo; 64 65 CXXSpecialNameExtra(QualType QT) : Type(QT), FETokenInfo(nullptr) {} 66 67 public: 68 void Profile(llvm::FoldingSetNodeID &ID) { 69 ID.AddPointer(Type.getAsOpaquePtr()); 70 } 71 }; 72 73 /// Contains extra information for the name of a C++ deduction guide. 74 class alignas(IdentifierInfoAlignment) CXXDeductionGuideNameExtra 75 : public detail::DeclarationNameExtra, 76 public llvm::FoldingSetNode { 77 friend class clang::DeclarationName; 78 friend class clang::DeclarationNameTable; 79 80 /// The template named by the deduction guide. 81 TemplateDecl *Template; 82 83 /// Extra information associated with this operator name that 84 /// can be used by the front end. All bits are really needed 85 /// so it is not possible to stash something in the low order bits. 86 void *FETokenInfo; 87 88 CXXDeductionGuideNameExtra(TemplateDecl *TD) 89 : DeclarationNameExtra(CXXDeductionGuideName), Template(TD), 90 FETokenInfo(nullptr) {} 91 92 public: 93 void Profile(llvm::FoldingSetNodeID &ID) { ID.AddPointer(Template); } 94 }; 95 96 /// Contains extra information for the name of an overloaded operator 97 /// in C++, such as "operator+. This do not includes literal or conversion 98 /// operators. For literal operators see CXXLiteralOperatorIdName and for 99 /// conversion operators see CXXSpecialNameExtra. 100 class alignas(IdentifierInfoAlignment) CXXOperatorIdName { 101 friend class clang::DeclarationName; 102 friend class clang::DeclarationNameTable; 103 104 /// The kind of this operator. 105 OverloadedOperatorKind Kind = OO_None; 106 107 /// Extra information associated with this operator name that 108 /// can be used by the front end. All bits are really needed 109 /// so it is not possible to stash something in the low order bits. 110 void *FETokenInfo = nullptr; 111 }; 112 113 /// Contains the actual identifier that makes up the 114 /// name of a C++ literal operator. 115 class alignas(IdentifierInfoAlignment) CXXLiteralOperatorIdName 116 : public detail::DeclarationNameExtra, 117 public llvm::FoldingSetNode { 118 friend class clang::DeclarationName; 119 friend class clang::DeclarationNameTable; 120 121 IdentifierInfo *ID; 122 123 /// Extra information associated with this operator name that 124 /// can be used by the front end. All bits are really needed 125 /// so it is not possible to stash something in the low order bits. 126 void *FETokenInfo; 127 128 CXXLiteralOperatorIdName(IdentifierInfo *II) 129 : DeclarationNameExtra(CXXLiteralOperatorName), ID(II), 130 FETokenInfo(nullptr) {} 131 132 public: 133 void Profile(llvm::FoldingSetNodeID &FSID) { FSID.AddPointer(ID); } 134 }; 135 136 } // namespace detail 137 138 /// The name of a declaration. In the common case, this just stores 139 /// an IdentifierInfo pointer to a normal name. However, it also provides 140 /// encodings for Objective-C selectors (optimizing zero- and one-argument 141 /// selectors, which make up 78% percent of all selectors in Cocoa.h), 142 /// special C++ names for constructors, destructors, and conversion functions, 143 /// and C++ overloaded operators. 144 class DeclarationName { 145 friend class DeclarationNameTable; 146 friend class NamedDecl; 147 148 /// StoredNameKind represent the kind of name that is actually stored in the 149 /// upper bits of the Ptr field. This is only used internally. 150 /// 151 /// NameKind, StoredNameKind, and DeclarationNameExtra::ExtraKind 152 /// must satisfy the following properties. These properties enable 153 /// efficient conversion between the various kinds. 154 /// 155 /// * The first seven enumerators of StoredNameKind must have the same 156 /// numerical value as the first seven enumerators of NameKind. 157 /// This enable efficient conversion between the two enumerations 158 /// in the usual case. 159 /// 160 /// * The enumerations values of DeclarationNameExtra::ExtraKind must start 161 /// at zero, and correspond to the numerical value of the first non-inline 162 /// enumeration values of NameKind minus an offset. This makes conversion 163 /// between DeclarationNameExtra::ExtraKind and NameKind possible with 164 /// a single addition/substraction. 165 /// 166 /// * The enumeration values of Selector::IdentifierInfoFlag must correspond 167 /// to the relevant enumeration values of StoredNameKind. 168 /// More specifically: 169 /// * ZeroArg == StoredObjCZeroArgSelector, 170 /// * OneArg == StoredObjCOneArgSelector, 171 /// * MultiArg == StoredDeclarationNameExtra 172 /// 173 /// * PtrMask must mask the low 3 bits of Ptr. 174 enum StoredNameKind { 175 StoredIdentifier = 0, 176 StoredObjCZeroArgSelector = Selector::ZeroArg, 177 StoredObjCOneArgSelector = Selector::OneArg, 178 StoredCXXConstructorName = 3, 179 StoredCXXDestructorName = 4, 180 StoredCXXConversionFunctionName = 5, 181 StoredCXXOperatorName = 6, 182 StoredDeclarationNameExtra = Selector::MultiArg, 183 PtrMask = 7, 184 UncommonNameKindOffset = 8 185 }; 186 187 static_assert(alignof(IdentifierInfo) >= 8 && 188 alignof(detail::DeclarationNameExtra) >= 8 && 189 alignof(detail::CXXSpecialNameExtra) >= 8 && 190 alignof(detail::CXXOperatorIdName) >= 8 && 191 alignof(detail::CXXDeductionGuideNameExtra) >= 8 && 192 alignof(detail::CXXLiteralOperatorIdName) >= 8, 193 "The various classes that DeclarationName::Ptr can point to" 194 " must be at least aligned to 8 bytes!"); 195 196 static_assert( 197 std::is_same<std::underlying_type_t<StoredNameKind>, 198 std::underlying_type_t< 199 detail::DeclarationNameExtra::ExtraKind>>::value, 200 "The various enums used to compute values for NameKind should " 201 "all have the same underlying type"); 202 203 public: 204 /// The kind of the name stored in this DeclarationName. 205 /// The first 7 enumeration values are stored inline and correspond 206 /// to frequently used kinds. The rest is stored in DeclarationNameExtra 207 /// and correspond to infrequently used kinds. 208 enum NameKind { 209 Identifier = StoredIdentifier, 210 ObjCZeroArgSelector = StoredObjCZeroArgSelector, 211 ObjCOneArgSelector = StoredObjCOneArgSelector, 212 CXXConstructorName = StoredCXXConstructorName, 213 CXXDestructorName = StoredCXXDestructorName, 214 CXXConversionFunctionName = StoredCXXConversionFunctionName, 215 CXXOperatorName = StoredCXXOperatorName, 216 CXXDeductionGuideName = llvm::addEnumValues( 217 UncommonNameKindOffset, 218 detail::DeclarationNameExtra::CXXDeductionGuideName), 219 CXXLiteralOperatorName = llvm::addEnumValues( 220 UncommonNameKindOffset, 221 detail::DeclarationNameExtra::CXXLiteralOperatorName), 222 CXXUsingDirective = 223 llvm::addEnumValues(UncommonNameKindOffset, 224 detail::DeclarationNameExtra::CXXUsingDirective), 225 ObjCMultiArgSelector = 226 llvm::addEnumValues(UncommonNameKindOffset, 227 detail::DeclarationNameExtra::ObjCMultiArgSelector), 228 }; 229 230 private: 231 /// The lowest three bits of Ptr are used to express what kind of name 232 /// we're actually storing, using the values of StoredNameKind. Depending 233 /// on the kind of name this is, the upper bits of Ptr may have one 234 /// of several different meanings: 235 /// 236 /// StoredIdentifier - The name is a normal identifier, and Ptr is 237 /// a normal IdentifierInfo pointer. 238 /// 239 /// StoredObjCZeroArgSelector - The name is an Objective-C 240 /// selector with zero arguments, and Ptr is an IdentifierInfo 241 /// pointer pointing to the selector name. 242 /// 243 /// StoredObjCOneArgSelector - The name is an Objective-C selector 244 /// with one argument, and Ptr is an IdentifierInfo pointer 245 /// pointing to the selector name. 246 /// 247 /// StoredCXXConstructorName - The name of a C++ constructor, 248 /// Ptr points to a CXXSpecialNameExtra. 249 /// 250 /// StoredCXXDestructorName - The name of a C++ destructor, 251 /// Ptr points to a CXXSpecialNameExtra. 252 /// 253 /// StoredCXXConversionFunctionName - The name of a C++ conversion function, 254 /// Ptr points to a CXXSpecialNameExtra. 255 /// 256 /// StoredCXXOperatorName - The name of an overloaded C++ operator, 257 /// Ptr points to a CXXOperatorIdName. 258 /// 259 /// StoredDeclarationNameExtra - Ptr is actually a pointer to a 260 /// DeclarationNameExtra structure, whose first value will tell us 261 /// whether this is an Objective-C selector, C++ deduction guide, 262 /// C++ literal operator, or C++ using directive. 263 uintptr_t Ptr = 0; 264 265 StoredNameKind getStoredNameKind() const { 266 return static_cast<StoredNameKind>(Ptr & PtrMask); 267 } 268 269 void *getPtr() const { return reinterpret_cast<void *>(Ptr & ~PtrMask); } 270 271 void setPtrAndKind(const void *P, StoredNameKind Kind) { 272 uintptr_t PAsInteger = reinterpret_cast<uintptr_t>(P); 273 assert((Kind & ~PtrMask) == 0 && 274 "Invalid StoredNameKind in setPtrAndKind!"); 275 assert((PAsInteger & PtrMask) == 0 && 276 "Improperly aligned pointer in setPtrAndKind!"); 277 Ptr = PAsInteger | Kind; 278 } 279 280 /// Construct a declaration name from a DeclarationNameExtra. 281 DeclarationName(detail::DeclarationNameExtra *Name) { 282 setPtrAndKind(Name, StoredDeclarationNameExtra); 283 } 284 285 /// Construct a declaration name from a CXXSpecialNameExtra. 286 DeclarationName(detail::CXXSpecialNameExtra *Name, 287 StoredNameKind StoredKind) { 288 assert((StoredKind == StoredCXXConstructorName || 289 StoredKind == StoredCXXDestructorName || 290 StoredKind == StoredCXXConversionFunctionName) && 291 "Invalid StoredNameKind when constructing a DeclarationName" 292 " from a CXXSpecialNameExtra!"); 293 setPtrAndKind(Name, StoredKind); 294 } 295 296 /// Construct a DeclarationName from a CXXOperatorIdName. 297 DeclarationName(detail::CXXOperatorIdName *Name) { 298 setPtrAndKind(Name, StoredCXXOperatorName); 299 } 300 301 /// Assert that the stored pointer points to an IdentifierInfo and return it. 302 IdentifierInfo *castAsIdentifierInfo() const { 303 assert((getStoredNameKind() == StoredIdentifier) && 304 "DeclarationName does not store an IdentifierInfo!"); 305 return static_cast<IdentifierInfo *>(getPtr()); 306 } 307 308 /// Assert that the stored pointer points to a DeclarationNameExtra 309 /// and return it. 310 detail::DeclarationNameExtra *castAsExtra() const { 311 assert((getStoredNameKind() == StoredDeclarationNameExtra) && 312 "DeclarationName does not store an Extra structure!"); 313 return static_cast<detail::DeclarationNameExtra *>(getPtr()); 314 } 315 316 /// Assert that the stored pointer points to a CXXSpecialNameExtra 317 /// and return it. 318 detail::CXXSpecialNameExtra *castAsCXXSpecialNameExtra() const { 319 assert((getStoredNameKind() == StoredCXXConstructorName || 320 getStoredNameKind() == StoredCXXDestructorName || 321 getStoredNameKind() == StoredCXXConversionFunctionName) && 322 "DeclarationName does not store a CXXSpecialNameExtra!"); 323 return static_cast<detail::CXXSpecialNameExtra *>(getPtr()); 324 } 325 326 /// Assert that the stored pointer points to a CXXOperatorIdName 327 /// and return it. 328 detail::CXXOperatorIdName *castAsCXXOperatorIdName() const { 329 assert((getStoredNameKind() == StoredCXXOperatorName) && 330 "DeclarationName does not store a CXXOperatorIdName!"); 331 return static_cast<detail::CXXOperatorIdName *>(getPtr()); 332 } 333 334 /// Assert that the stored pointer points to a CXXDeductionGuideNameExtra 335 /// and return it. 336 detail::CXXDeductionGuideNameExtra *castAsCXXDeductionGuideNameExtra() const { 337 assert(getNameKind() == CXXDeductionGuideName && 338 "DeclarationName does not store a CXXDeductionGuideNameExtra!"); 339 return static_cast<detail::CXXDeductionGuideNameExtra *>(getPtr()); 340 } 341 342 /// Assert that the stored pointer points to a CXXLiteralOperatorIdName 343 /// and return it. 344 detail::CXXLiteralOperatorIdName *castAsCXXLiteralOperatorIdName() const { 345 assert(getNameKind() == CXXLiteralOperatorName && 346 "DeclarationName does not store a CXXLiteralOperatorIdName!"); 347 return static_cast<detail::CXXLiteralOperatorIdName *>(getPtr()); 348 } 349 350 /// Get and set the FETokenInfo in the less common cases where the 351 /// declaration name do not point to an identifier. 352 void *getFETokenInfoSlow() const; 353 void setFETokenInfoSlow(void *T); 354 355 public: 356 /// Construct an empty declaration name. 357 DeclarationName() { setPtrAndKind(nullptr, StoredIdentifier); } 358 359 /// Construct a declaration name from an IdentifierInfo *. 360 DeclarationName(const IdentifierInfo *II) { 361 setPtrAndKind(II, StoredIdentifier); 362 } 363 364 /// Construct a declaration name from an Objective-C selector. 365 DeclarationName(Selector Sel) : Ptr(Sel.InfoPtr) {} 366 367 /// Returns the name for all C++ using-directives. 368 static DeclarationName getUsingDirectiveName() { 369 // Single instance of DeclarationNameExtra for using-directive 370 static detail::DeclarationNameExtra UDirExtra( 371 detail::DeclarationNameExtra::CXXUsingDirective); 372 return DeclarationName(&UDirExtra); 373 } 374 375 /// Evaluates true when this declaration name is non-empty. 376 explicit operator bool() const { 377 return getPtr() || (getStoredNameKind() != StoredIdentifier); 378 } 379 380 /// Evaluates true when this declaration name is empty. 381 bool isEmpty() const { return !*this; } 382 383 /// Predicate functions for querying what type of name this is. 384 bool isIdentifier() const { return getStoredNameKind() == StoredIdentifier; } 385 bool isObjCZeroArgSelector() const { 386 return getStoredNameKind() == StoredObjCZeroArgSelector; 387 } 388 bool isObjCOneArgSelector() const { 389 return getStoredNameKind() == StoredObjCOneArgSelector; 390 } 391 392 /// Determine what kind of name this is. 393 NameKind getNameKind() const { 394 // We rely on the fact that the first 7 NameKind and StoredNameKind 395 // have the same numerical value. This makes the usual case efficient. 396 StoredNameKind StoredKind = getStoredNameKind(); 397 if (StoredKind != StoredDeclarationNameExtra) 398 return static_cast<NameKind>(StoredKind); 399 // We have to consult DeclarationNameExtra. We rely on the fact that the 400 // enumeration values of ExtraKind correspond to the enumeration values of 401 // NameKind minus an offset of UncommonNameKindOffset. 402 unsigned ExtraKind = castAsExtra()->getKind(); 403 return static_cast<NameKind>(UncommonNameKindOffset + ExtraKind); 404 } 405 406 /// Determines whether the name itself is dependent, e.g., because it 407 /// involves a C++ type that is itself dependent. 408 /// 409 /// Note that this does not capture all of the notions of "dependent name", 410 /// because an identifier can be a dependent name if it is used as the 411 /// callee in a call expression with dependent arguments. 412 bool isDependentName() const; 413 414 /// Retrieve the human-readable string for this name. 415 std::string getAsString() const; 416 417 /// Retrieve the IdentifierInfo * stored in this declaration name, 418 /// or null if this declaration name isn't a simple identifier. 419 IdentifierInfo *getAsIdentifierInfo() const { 420 if (isIdentifier()) 421 return castAsIdentifierInfo(); 422 return nullptr; 423 } 424 425 /// Get the representation of this declaration name as an opaque integer. 426 uintptr_t getAsOpaqueInteger() const { return Ptr; } 427 428 /// Get the representation of this declaration name as an opaque pointer. 429 void *getAsOpaquePtr() const { return reinterpret_cast<void *>(Ptr); } 430 431 /// Get a declaration name from an opaque pointer returned by getAsOpaquePtr. 432 static DeclarationName getFromOpaquePtr(void *P) { 433 DeclarationName N; 434 N.Ptr = reinterpret_cast<uintptr_t>(P); 435 return N; 436 } 437 438 /// Get a declaration name from an opaque integer 439 /// returned by getAsOpaqueInteger. 440 static DeclarationName getFromOpaqueInteger(uintptr_t P) { 441 DeclarationName N; 442 N.Ptr = P; 443 return N; 444 } 445 446 /// If this name is one of the C++ names (of a constructor, destructor, 447 /// or conversion function), return the type associated with that name. 448 QualType getCXXNameType() const { 449 if (getStoredNameKind() == StoredCXXConstructorName || 450 getStoredNameKind() == StoredCXXDestructorName || 451 getStoredNameKind() == StoredCXXConversionFunctionName) { 452 assert(getPtr() && "getCXXNameType on a null DeclarationName!"); 453 return castAsCXXSpecialNameExtra()->Type; 454 } 455 return QualType(); 456 } 457 458 /// If this name is the name of a C++ deduction guide, return the 459 /// template associated with that name. 460 TemplateDecl *getCXXDeductionGuideTemplate() const { 461 if (getNameKind() == CXXDeductionGuideName) { 462 assert(getPtr() && 463 "getCXXDeductionGuideTemplate on a null DeclarationName!"); 464 return castAsCXXDeductionGuideNameExtra()->Template; 465 } 466 return nullptr; 467 } 468 469 /// If this name is the name of an overloadable operator in C++ 470 /// (e.g., @c operator+), retrieve the kind of overloaded operator. 471 OverloadedOperatorKind getCXXOverloadedOperator() const { 472 if (getStoredNameKind() == StoredCXXOperatorName) { 473 assert(getPtr() && "getCXXOverloadedOperator on a null DeclarationName!"); 474 return castAsCXXOperatorIdName()->Kind; 475 } 476 return OO_None; 477 } 478 479 /// If this name is the name of a literal operator, 480 /// retrieve the identifier associated with it. 481 IdentifierInfo *getCXXLiteralIdentifier() const { 482 if (getNameKind() == CXXLiteralOperatorName) { 483 assert(getPtr() && "getCXXLiteralIdentifier on a null DeclarationName!"); 484 return castAsCXXLiteralOperatorIdName()->ID; 485 } 486 return nullptr; 487 } 488 489 /// Get the Objective-C selector stored in this declaration name. 490 Selector getObjCSelector() const { 491 assert((getNameKind() == ObjCZeroArgSelector || 492 getNameKind() == ObjCOneArgSelector || 493 getNameKind() == ObjCMultiArgSelector || !getPtr()) && 494 "Not a selector!"); 495 return Selector(Ptr); 496 } 497 498 /// Get and set FETokenInfo. The language front-end is allowed to associate 499 /// arbitrary metadata with some kinds of declaration names, including normal 500 /// identifiers and C++ constructors, destructors, and conversion functions. 501 void *getFETokenInfo() const { 502 assert(getPtr() && "getFETokenInfo on an empty DeclarationName!"); 503 if (getStoredNameKind() == StoredIdentifier) 504 return castAsIdentifierInfo()->getFETokenInfo(); 505 return getFETokenInfoSlow(); 506 } 507 508 void setFETokenInfo(void *T) { 509 assert(getPtr() && "setFETokenInfo on an empty DeclarationName!"); 510 if (getStoredNameKind() == StoredIdentifier) 511 castAsIdentifierInfo()->setFETokenInfo(T); 512 else 513 setFETokenInfoSlow(T); 514 } 515 516 /// Determine whether the specified names are identical. 517 friend bool operator==(DeclarationName LHS, DeclarationName RHS) { 518 return LHS.Ptr == RHS.Ptr; 519 } 520 521 /// Determine whether the specified names are different. 522 friend bool operator!=(DeclarationName LHS, DeclarationName RHS) { 523 return LHS.Ptr != RHS.Ptr; 524 } 525 526 static DeclarationName getEmptyMarker() { 527 DeclarationName Name; 528 Name.Ptr = uintptr_t(-1); 529 return Name; 530 } 531 532 static DeclarationName getTombstoneMarker() { 533 DeclarationName Name; 534 Name.Ptr = uintptr_t(-2); 535 return Name; 536 } 537 538 static int compare(DeclarationName LHS, DeclarationName RHS); 539 540 void print(raw_ostream &OS, const PrintingPolicy &Policy) const; 541 542 void dump() const; 543 }; 544 545 raw_ostream &operator<<(raw_ostream &OS, DeclarationName N); 546 547 /// Ordering on two declaration names. If both names are identifiers, 548 /// this provides a lexicographical ordering. 549 inline bool operator<(DeclarationName LHS, DeclarationName RHS) { 550 return DeclarationName::compare(LHS, RHS) < 0; 551 } 552 553 /// Ordering on two declaration names. If both names are identifiers, 554 /// this provides a lexicographical ordering. 555 inline bool operator>(DeclarationName LHS, DeclarationName RHS) { 556 return DeclarationName::compare(LHS, RHS) > 0; 557 } 558 559 /// Ordering on two declaration names. If both names are identifiers, 560 /// this provides a lexicographical ordering. 561 inline bool operator<=(DeclarationName LHS, DeclarationName RHS) { 562 return DeclarationName::compare(LHS, RHS) <= 0; 563 } 564 565 /// Ordering on two declaration names. If both names are identifiers, 566 /// this provides a lexicographical ordering. 567 inline bool operator>=(DeclarationName LHS, DeclarationName RHS) { 568 return DeclarationName::compare(LHS, RHS) >= 0; 569 } 570 571 /// DeclarationNameTable is used to store and retrieve DeclarationName 572 /// instances for the various kinds of declaration names, e.g., normal 573 /// identifiers, C++ constructor names, etc. This class contains 574 /// uniqued versions of each of the C++ special names, which can be 575 /// retrieved using its member functions (e.g., getCXXConstructorName). 576 class DeclarationNameTable { 577 /// Used to allocate elements in the FoldingSets below. 578 const ASTContext &Ctx; 579 580 /// Manage the uniqued CXXSpecialNameExtra representing C++ constructors. 581 /// getCXXConstructorName and getCXXSpecialName can be used to obtain 582 /// a DeclarationName from the corresponding type of the constructor. 583 llvm::FoldingSet<detail::CXXSpecialNameExtra> CXXConstructorNames; 584 585 /// Manage the uniqued CXXSpecialNameExtra representing C++ destructors. 586 /// getCXXDestructorName and getCXXSpecialName can be used to obtain 587 /// a DeclarationName from the corresponding type of the destructor. 588 llvm::FoldingSet<detail::CXXSpecialNameExtra> CXXDestructorNames; 589 590 /// Manage the uniqued CXXSpecialNameExtra representing C++ conversion 591 /// functions. getCXXConversionFunctionName and getCXXSpecialName can be 592 /// used to obtain a DeclarationName from the corresponding type of the 593 /// conversion function. 594 llvm::FoldingSet<detail::CXXSpecialNameExtra> CXXConversionFunctionNames; 595 596 /// Manage the uniqued CXXOperatorIdName, which contain extra information 597 /// for the name of overloaded C++ operators. getCXXOperatorName 598 /// can be used to obtain a DeclarationName from the operator kind. 599 detail::CXXOperatorIdName CXXOperatorNames[NUM_OVERLOADED_OPERATORS]; 600 601 /// Manage the uniqued CXXLiteralOperatorIdName, which contain extra 602 /// information for the name of C++ literal operators. 603 /// getCXXLiteralOperatorName can be used to obtain a DeclarationName 604 /// from the corresponding IdentifierInfo. 605 llvm::FoldingSet<detail::CXXLiteralOperatorIdName> CXXLiteralOperatorNames; 606 607 /// Manage the uniqued CXXDeductionGuideNameExtra, which contain 608 /// extra information for the name of a C++ deduction guide. 609 /// getCXXDeductionGuideName can be used to obtain a DeclarationName 610 /// from the corresponding template declaration. 611 llvm::FoldingSet<detail::CXXDeductionGuideNameExtra> CXXDeductionGuideNames; 612 613 public: 614 DeclarationNameTable(const ASTContext &C); 615 DeclarationNameTable(const DeclarationNameTable &) = delete; 616 DeclarationNameTable &operator=(const DeclarationNameTable &) = delete; 617 DeclarationNameTable(DeclarationNameTable &&) = delete; 618 DeclarationNameTable &operator=(DeclarationNameTable &&) = delete; 619 ~DeclarationNameTable() = default; 620 621 /// Create a declaration name that is a simple identifier. 622 DeclarationName getIdentifier(const IdentifierInfo *ID) { 623 return DeclarationName(ID); 624 } 625 626 /// Returns the name of a C++ constructor for the given Type. 627 DeclarationName getCXXConstructorName(CanQualType Ty); 628 629 /// Returns the name of a C++ destructor for the given Type. 630 DeclarationName getCXXDestructorName(CanQualType Ty); 631 632 /// Returns the name of a C++ deduction guide for the given template. 633 DeclarationName getCXXDeductionGuideName(TemplateDecl *TD); 634 635 /// Returns the name of a C++ conversion function for the given Type. 636 DeclarationName getCXXConversionFunctionName(CanQualType Ty); 637 638 /// Returns a declaration name for special kind of C++ name, 639 /// e.g., for a constructor, destructor, or conversion function. 640 /// Kind must be one of: 641 /// * DeclarationName::CXXConstructorName, 642 /// * DeclarationName::CXXDestructorName or 643 /// * DeclarationName::CXXConversionFunctionName 644 DeclarationName getCXXSpecialName(DeclarationName::NameKind Kind, 645 CanQualType Ty); 646 647 /// Get the name of the overloadable C++ operator corresponding to Op. 648 DeclarationName getCXXOperatorName(OverloadedOperatorKind Op) { 649 return DeclarationName(&CXXOperatorNames[Op]); 650 } 651 652 /// Get the name of the literal operator function with II as the identifier. 653 DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II); 654 }; 655 656 /// DeclarationNameLoc - Additional source/type location info 657 /// for a declaration name. Needs a DeclarationName in order 658 /// to be interpreted correctly. 659 class DeclarationNameLoc { 660 // The source location for identifier stored elsewhere. 661 // struct {} Identifier; 662 663 // Type info for constructors, destructors and conversion functions. 664 // Locations (if any) for the tilde (destructor) or operator keyword 665 // (conversion) are stored elsewhere. 666 struct NT { 667 TypeSourceInfo *TInfo; 668 }; 669 670 // The location (if any) of the operator keyword is stored elsewhere. 671 struct CXXOpName { 672 SourceLocation::UIntTy BeginOpNameLoc; 673 SourceLocation::UIntTy EndOpNameLoc; 674 }; 675 676 // The location (if any) of the operator keyword is stored elsewhere. 677 struct CXXLitOpName { 678 SourceLocation::UIntTy OpNameLoc; 679 }; 680 681 // struct {} CXXUsingDirective; 682 // struct {} ObjCZeroArgSelector; 683 // struct {} ObjCOneArgSelector; 684 // struct {} ObjCMultiArgSelector; 685 union { 686 struct NT NamedType; 687 struct CXXOpName CXXOperatorName; 688 struct CXXLitOpName CXXLiteralOperatorName; 689 }; 690 691 void setNamedTypeLoc(TypeSourceInfo *TInfo) { NamedType.TInfo = TInfo; } 692 693 void setCXXOperatorNameRange(SourceRange Range) { 694 CXXOperatorName.BeginOpNameLoc = Range.getBegin().getRawEncoding(); 695 CXXOperatorName.EndOpNameLoc = Range.getEnd().getRawEncoding(); 696 } 697 698 void setCXXLiteralOperatorNameLoc(SourceLocation Loc) { 699 CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding(); 700 } 701 702 public: 703 DeclarationNameLoc(DeclarationName Name); 704 // FIXME: this should go away once all DNLocs are properly initialized. 705 DeclarationNameLoc() { memset((void*) this, 0, sizeof(*this)); } 706 707 /// Returns the source type info. Assumes that the object stores location 708 /// information of a constructor, destructor or conversion operator. 709 TypeSourceInfo *getNamedTypeInfo() const { return NamedType.TInfo; } 710 711 /// Return the beginning location of the getCXXOperatorNameRange() range. 712 SourceLocation getCXXOperatorNameBeginLoc() const { 713 return SourceLocation::getFromRawEncoding(CXXOperatorName.BeginOpNameLoc); 714 } 715 716 /// Return the end location of the getCXXOperatorNameRange() range. 717 SourceLocation getCXXOperatorNameEndLoc() const { 718 return SourceLocation::getFromRawEncoding(CXXOperatorName.EndOpNameLoc); 719 } 720 721 /// Return the range of the operator name (without the operator keyword). 722 /// Assumes that the object stores location information of a (non-literal) 723 /// operator. 724 SourceRange getCXXOperatorNameRange() const { 725 return SourceRange(getCXXOperatorNameBeginLoc(), 726 getCXXOperatorNameEndLoc()); 727 } 728 729 /// Return the location of the literal operator name (without the operator 730 /// keyword). Assumes that the object stores location information of a literal 731 /// operator. 732 SourceLocation getCXXLiteralOperatorNameLoc() const { 733 return SourceLocation::getFromRawEncoding(CXXLiteralOperatorName.OpNameLoc); 734 } 735 736 /// Construct location information for a constructor, destructor or conversion 737 /// operator. 738 static DeclarationNameLoc makeNamedTypeLoc(TypeSourceInfo *TInfo) { 739 DeclarationNameLoc DNL; 740 DNL.setNamedTypeLoc(TInfo); 741 return DNL; 742 } 743 744 /// Construct location information for a non-literal C++ operator. 745 static DeclarationNameLoc makeCXXOperatorNameLoc(SourceLocation BeginLoc, 746 SourceLocation EndLoc) { 747 return makeCXXOperatorNameLoc(SourceRange(BeginLoc, EndLoc)); 748 } 749 750 /// Construct location information for a non-literal C++ operator. 751 static DeclarationNameLoc makeCXXOperatorNameLoc(SourceRange Range) { 752 DeclarationNameLoc DNL; 753 DNL.setCXXOperatorNameRange(Range); 754 return DNL; 755 } 756 757 /// Construct location information for a literal C++ operator. 758 static DeclarationNameLoc makeCXXLiteralOperatorNameLoc(SourceLocation Loc) { 759 DeclarationNameLoc DNL; 760 DNL.setCXXLiteralOperatorNameLoc(Loc); 761 return DNL; 762 } 763 }; 764 765 /// DeclarationNameInfo - A collector data type for bundling together 766 /// a DeclarationName and the correspnding source/type location info. 767 struct DeclarationNameInfo { 768 private: 769 /// Name - The declaration name, also encoding name kind. 770 DeclarationName Name; 771 772 /// Loc - The main source location for the declaration name. 773 SourceLocation NameLoc; 774 775 /// Info - Further source/type location info for special kinds of names. 776 DeclarationNameLoc LocInfo; 777 778 public: 779 // FIXME: remove it. 780 DeclarationNameInfo() = default; 781 782 DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc) 783 : Name(Name), NameLoc(NameLoc), LocInfo(Name) {} 784 785 DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc, 786 DeclarationNameLoc LocInfo) 787 : Name(Name), NameLoc(NameLoc), LocInfo(LocInfo) {} 788 789 /// getName - Returns the embedded declaration name. 790 DeclarationName getName() const { return Name; } 791 792 /// setName - Sets the embedded declaration name. 793 void setName(DeclarationName N) { Name = N; } 794 795 /// getLoc - Returns the main location of the declaration name. 796 SourceLocation getLoc() const { return NameLoc; } 797 798 /// setLoc - Sets the main location of the declaration name. 799 void setLoc(SourceLocation L) { NameLoc = L; } 800 801 const DeclarationNameLoc &getInfo() const { return LocInfo; } 802 void setInfo(const DeclarationNameLoc &Info) { LocInfo = Info; } 803 804 /// getNamedTypeInfo - Returns the source type info associated to 805 /// the name. Assumes it is a constructor, destructor or conversion. 806 TypeSourceInfo *getNamedTypeInfo() const { 807 if (Name.getNameKind() != DeclarationName::CXXConstructorName && 808 Name.getNameKind() != DeclarationName::CXXDestructorName && 809 Name.getNameKind() != DeclarationName::CXXConversionFunctionName) 810 return nullptr; 811 return LocInfo.getNamedTypeInfo(); 812 } 813 814 /// setNamedTypeInfo - Sets the source type info associated to 815 /// the name. Assumes it is a constructor, destructor or conversion. 816 void setNamedTypeInfo(TypeSourceInfo *TInfo) { 817 assert(Name.getNameKind() == DeclarationName::CXXConstructorName || 818 Name.getNameKind() == DeclarationName::CXXDestructorName || 819 Name.getNameKind() == DeclarationName::CXXConversionFunctionName); 820 LocInfo = DeclarationNameLoc::makeNamedTypeLoc(TInfo); 821 } 822 823 /// getCXXOperatorNameRange - Gets the range of the operator name 824 /// (without the operator keyword). Assumes it is a (non-literal) operator. 825 SourceRange getCXXOperatorNameRange() const { 826 if (Name.getNameKind() != DeclarationName::CXXOperatorName) 827 return SourceRange(); 828 return LocInfo.getCXXOperatorNameRange(); 829 } 830 831 /// setCXXOperatorNameRange - Sets the range of the operator name 832 /// (without the operator keyword). Assumes it is a C++ operator. 833 void setCXXOperatorNameRange(SourceRange R) { 834 assert(Name.getNameKind() == DeclarationName::CXXOperatorName); 835 LocInfo = DeclarationNameLoc::makeCXXOperatorNameLoc(R); 836 } 837 838 /// getCXXLiteralOperatorNameLoc - Returns the location of the literal 839 /// operator name (not the operator keyword). 840 /// Assumes it is a literal operator. 841 SourceLocation getCXXLiteralOperatorNameLoc() const { 842 if (Name.getNameKind() != DeclarationName::CXXLiteralOperatorName) 843 return SourceLocation(); 844 return LocInfo.getCXXLiteralOperatorNameLoc(); 845 } 846 847 /// setCXXLiteralOperatorNameLoc - Sets the location of the literal 848 /// operator name (not the operator keyword). 849 /// Assumes it is a literal operator. 850 void setCXXLiteralOperatorNameLoc(SourceLocation Loc) { 851 assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName); 852 LocInfo = DeclarationNameLoc::makeCXXLiteralOperatorNameLoc(Loc); 853 } 854 855 /// Determine whether this name involves a template parameter. 856 bool isInstantiationDependent() const; 857 858 /// Determine whether this name contains an unexpanded 859 /// parameter pack. 860 bool containsUnexpandedParameterPack() const; 861 862 /// getAsString - Retrieve the human-readable string for this name. 863 std::string getAsString() const; 864 865 /// printName - Print the human-readable name to a stream. 866 void printName(raw_ostream &OS, PrintingPolicy Policy) const; 867 868 /// getBeginLoc - Retrieve the location of the first token. 869 SourceLocation getBeginLoc() const { return NameLoc; } 870 871 /// getSourceRange - The range of the declaration name. 872 SourceRange getSourceRange() const LLVM_READONLY { 873 return SourceRange(getBeginLoc(), getEndLoc()); 874 } 875 876 SourceLocation getEndLoc() const LLVM_READONLY { 877 SourceLocation EndLoc = getEndLocPrivate(); 878 return EndLoc.isValid() ? EndLoc : getBeginLoc(); 879 } 880 881 private: 882 SourceLocation getEndLocPrivate() const; 883 }; 884 885 /// Insertion operator for partial diagnostics. This allows binding 886 /// DeclarationName's into a partial diagnostic with <<. 887 inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD, 888 DeclarationName N) { 889 PD.AddTaggedVal(N.getAsOpaqueInteger(), 890 DiagnosticsEngine::ak_declarationname); 891 return PD; 892 } 893 894 raw_ostream &operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo); 895 896 } // namespace clang 897 898 namespace llvm { 899 900 /// Define DenseMapInfo so that DeclarationNames can be used as keys 901 /// in DenseMap and DenseSets. 902 template<> 903 struct DenseMapInfo<clang::DeclarationName> { 904 static inline clang::DeclarationName getEmptyKey() { 905 return clang::DeclarationName::getEmptyMarker(); 906 } 907 908 static inline clang::DeclarationName getTombstoneKey() { 909 return clang::DeclarationName::getTombstoneMarker(); 910 } 911 912 static unsigned getHashValue(clang::DeclarationName Name) { 913 return DenseMapInfo<void*>::getHashValue(Name.getAsOpaquePtr()); 914 } 915 916 static inline bool 917 isEqual(clang::DeclarationName LHS, clang::DeclarationName RHS) { 918 return LHS == RHS; 919 } 920 }; 921 922 template <> struct PointerLikeTypeTraits<clang::DeclarationName> { 923 static inline void *getAsVoidPointer(clang::DeclarationName P) { 924 return P.getAsOpaquePtr(); 925 } 926 static inline clang::DeclarationName getFromVoidPointer(void *P) { 927 return clang::DeclarationName::getFromOpaquePtr(P); 928 } 929 static constexpr int NumLowBitsAvailable = 0; 930 }; 931 932 } // namespace llvm 933 934 // The definition of AssumedTemplateStorage is factored out of TemplateName to 935 // resolve a cyclic dependency between it and DeclarationName (via Type). 936 namespace clang { 937 938 /// A structure for storing the information associated with a name that has 939 /// been assumed to be a template name (despite finding no TemplateDecls). 940 class AssumedTemplateStorage : public UncommonTemplateNameStorage { 941 friend class ASTContext; 942 943 AssumedTemplateStorage(DeclarationName Name) 944 : UncommonTemplateNameStorage(Assumed, 0), Name(Name) {} 945 DeclarationName Name; 946 947 public: 948 /// Get the name of the template. 949 DeclarationName getDeclName() const { return Name; } 950 }; 951 952 } // namespace clang 953 954 #endif // LLVM_CLANG_AST_DECLARATIONNAME_H 955