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