DeclarationName.h revision 7fe0b9ea2c8137c035402e6ea01dfdfbc93214cb
1//===-- DeclarationName.h - Representation of declaration names -*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file declares the DeclarationName and DeclarationNameTable classes. 11// 12//===----------------------------------------------------------------------===// 13#ifndef LLVM_CLANG_AST_DECLARATIONNAME_H 14#define LLVM_CLANG_AST_DECLARATIONNAME_H 15 16#include "clang/Basic/IdentifierTable.h" 17#include "clang/AST/Type.h" 18#include "clang/AST/CanonicalType.h" 19#include "clang/Basic/PartialDiagnostic.h" 20 21namespace llvm { 22 template <typename T> struct DenseMapInfo; 23} 24 25namespace clang { 26 class CXXSpecialName; 27 class CXXOperatorIdName; 28 class CXXLiteralOperatorIdName; 29 class DeclarationNameExtra; 30 class IdentifierInfo; 31 class MultiKeywordSelector; 32 class UsingDirectiveDecl; 33 34/// DeclarationName - The name of a declaration. In the common case, 35/// this just stores an IdentifierInfo pointer to a normal 36/// name. However, it also provides encodings for Objective-C 37/// selectors (optimizing zero- and one-argument selectors, which make 38/// up 78% percent of all selectors in Cocoa.h) and special C++ names 39/// for constructors, destructors, and conversion functions. 40class DeclarationName { 41public: 42 /// NameKind - The kind of name this object contains. 43 enum NameKind { 44 Identifier, 45 ObjCZeroArgSelector, 46 ObjCOneArgSelector, 47 ObjCMultiArgSelector, 48 CXXConstructorName, 49 CXXDestructorName, 50 CXXConversionFunctionName, 51 CXXOperatorName, 52 CXXLiteralOperatorName, 53 CXXUsingDirective 54 }; 55 56private: 57 /// StoredNameKind - The kind of name that is actually stored in the 58 /// upper bits of the Ptr field. This is only used internally. 59 enum StoredNameKind { 60 StoredIdentifier = 0, 61 StoredObjCZeroArgSelector, 62 StoredObjCOneArgSelector, 63 StoredDeclarationNameExtra, 64 PtrMask = 0x03 65 }; 66 67 /// Ptr - The lowest two bits are used to express what kind of name 68 /// we're actually storing, using the values of NameKind. Depending 69 /// on the kind of name this is, the upper bits of Ptr may have one 70 /// of several different meanings: 71 /// 72 /// StoredIdentifier - The name is a normal identifier, and Ptr is 73 /// a normal IdentifierInfo pointer. 74 /// 75 /// StoredObjCZeroArgSelector - The name is an Objective-C 76 /// selector with zero arguments, and Ptr is an IdentifierInfo 77 /// pointer pointing to the selector name. 78 /// 79 /// StoredObjCOneArgSelector - The name is an Objective-C selector 80 /// with one argument, and Ptr is an IdentifierInfo pointer 81 /// pointing to the selector name. 82 /// 83 /// StoredDeclarationNameExtra - Ptr is actually a pointer to a 84 /// DeclarationNameExtra structure, whose first value will tell us 85 /// whether this is an Objective-C selector, C++ operator-id name, 86 /// or special C++ name. 87 uintptr_t Ptr; 88 89 /// getStoredNameKind - Return the kind of object that is stored in 90 /// Ptr. 91 StoredNameKind getStoredNameKind() const { 92 return static_cast<StoredNameKind>(Ptr & PtrMask); 93 } 94 95 /// getExtra - Get the "extra" information associated with this 96 /// multi-argument selector or C++ special name. 97 DeclarationNameExtra *getExtra() const { 98 assert(getStoredNameKind() == StoredDeclarationNameExtra && 99 "Declaration name does not store an Extra structure"); 100 return reinterpret_cast<DeclarationNameExtra *>(Ptr & ~PtrMask); 101 } 102 103 /// getAsCXXSpecialName - If the stored pointer is actually a 104 /// CXXSpecialName, returns a pointer to it. Otherwise, returns 105 /// a NULL pointer. 106 CXXSpecialName *getAsCXXSpecialName() const { 107 if (getNameKind() >= CXXConstructorName && 108 getNameKind() <= CXXConversionFunctionName) 109 return reinterpret_cast<CXXSpecialName *>(Ptr & ~PtrMask); 110 return 0; 111 } 112 113 /// getAsCXXOperatorIdName 114 CXXOperatorIdName *getAsCXXOperatorIdName() const { 115 if (getNameKind() == CXXOperatorName) 116 return reinterpret_cast<CXXOperatorIdName *>(Ptr & ~PtrMask); 117 return 0; 118 } 119 120 CXXLiteralOperatorIdName *getAsCXXLiteralOperatorIdName() const { 121 if (getNameKind() == CXXLiteralOperatorName) 122 return reinterpret_cast<CXXLiteralOperatorIdName *>(Ptr & ~PtrMask); 123 return 0; 124 } 125 126 // Construct a declaration name from the name of a C++ constructor, 127 // destructor, or conversion function. 128 DeclarationName(CXXSpecialName *Name) 129 : Ptr(reinterpret_cast<uintptr_t>(Name)) { 130 assert((Ptr & PtrMask) == 0 && "Improperly aligned CXXSpecialName"); 131 Ptr |= StoredDeclarationNameExtra; 132 } 133 134 // Construct a declaration name from the name of a C++ overloaded 135 // operator. 136 DeclarationName(CXXOperatorIdName *Name) 137 : Ptr(reinterpret_cast<uintptr_t>(Name)) { 138 assert((Ptr & PtrMask) == 0 && "Improperly aligned CXXOperatorId"); 139 Ptr |= StoredDeclarationNameExtra; 140 } 141 142 DeclarationName(CXXLiteralOperatorIdName *Name) 143 : Ptr(reinterpret_cast<uintptr_t>(Name)) { 144 assert((Ptr & PtrMask) == 0 && "Improperly aligned CXXLiteralOperatorId"); 145 Ptr |= StoredDeclarationNameExtra; 146 } 147 148 /// Construct a declaration name from a raw pointer. 149 DeclarationName(uintptr_t Ptr) : Ptr(Ptr) { } 150 151 friend class DeclarationNameTable; 152 friend class NamedDecl; 153 154 /// getFETokenInfoAsVoid - Retrieves the front end-specified pointer 155 /// for this name as a void pointer. 156 void *getFETokenInfoAsVoid() const; 157 158public: 159 /// DeclarationName - Used to create an empty selector. 160 DeclarationName() : Ptr(0) { } 161 162 // Construct a declaration name from an IdentifierInfo *. 163 DeclarationName(const IdentifierInfo *II) 164 : Ptr(reinterpret_cast<uintptr_t>(II)) { 165 assert((Ptr & PtrMask) == 0 && "Improperly aligned IdentifierInfo"); 166 } 167 168 // Construct a declaration name from an Objective-C selector. 169 DeclarationName(Selector Sel); 170 171 /// getUsingDirectiveName - Return name for all using-directives. 172 static DeclarationName getUsingDirectiveName(); 173 174 // operator bool() - Evaluates true when this declaration name is 175 // non-empty. 176 operator bool() const { 177 return ((Ptr & PtrMask) != 0) || 178 (reinterpret_cast<IdentifierInfo *>(Ptr & ~PtrMask)); 179 } 180 181 /// Predicate functions for querying what type of name this is. 182 bool isIdentifier() const { return getStoredNameKind() == StoredIdentifier; } 183 bool isObjCZeroArgSelector() const { 184 return getStoredNameKind() == StoredObjCZeroArgSelector; 185 } 186 bool isObjCOneArgSelector() const { 187 return getStoredNameKind() == StoredObjCOneArgSelector; 188 } 189 190 /// getNameKind - Determine what kind of name this is. 191 NameKind getNameKind() const; 192 193 /// \brief Determines whether the name itself is dependent, e.g., because it 194 /// involves a C++ type that is itself dependent. 195 /// 196 /// Note that this does not capture all of the notions of "dependent name", 197 /// because an identifier can be a dependent name if it is used as the 198 /// callee in a call expression with dependent arguments. 199 bool isDependentName() const; 200 201 /// getName - Retrieve the human-readable string for this name. 202 std::string getAsString() const; 203 204 /// getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in 205 /// this declaration name, or NULL if this declaration name isn't a 206 /// simple identifier. 207 IdentifierInfo *getAsIdentifierInfo() const { 208 if (isIdentifier()) 209 return reinterpret_cast<IdentifierInfo *>(Ptr); 210 return 0; 211 } 212 213 /// getAsOpaqueInteger - Get the representation of this declaration 214 /// name as an opaque integer. 215 uintptr_t getAsOpaqueInteger() const { return Ptr; } 216 217 /// getAsOpaquePtr - Get the representation of this declaration name as 218 /// an opaque pointer. 219 void *getAsOpaquePtr() const { return reinterpret_cast<void*>(Ptr); } 220 221 static DeclarationName getFromOpaquePtr(void *P) { 222 DeclarationName N; 223 N.Ptr = reinterpret_cast<uintptr_t> (P); 224 return N; 225 } 226 227 static DeclarationName getFromOpaqueInteger(uintptr_t P) { 228 DeclarationName N; 229 N.Ptr = P; 230 return N; 231 } 232 233 /// getCXXNameType - If this name is one of the C++ names (of a 234 /// constructor, destructor, or conversion function), return the 235 /// type associated with that name. 236 QualType getCXXNameType() const; 237 238 /// getCXXOverloadedOperator - If this name is the name of an 239 /// overloadable operator in C++ (e.g., @c operator+), retrieve the 240 /// kind of overloaded operator. 241 OverloadedOperatorKind getCXXOverloadedOperator() const; 242 243 /// getCXXLiteralIdentifier - If this name is the name of a literal 244 /// operator, retrieve the identifier associated with it. 245 IdentifierInfo *getCXXLiteralIdentifier() const; 246 247 /// getObjCSelector - Get the Objective-C selector stored in this 248 /// declaration name. 249 Selector getObjCSelector() const; 250 251 /// getFETokenInfo/setFETokenInfo - The language front-end is 252 /// allowed to associate arbitrary metadata with some kinds of 253 /// declaration names, including normal identifiers and C++ 254 /// constructors, destructors, and conversion functions. 255 template<typename T> 256 T *getFETokenInfo() const { return static_cast<T*>(getFETokenInfoAsVoid()); } 257 258 void setFETokenInfo(void *T); 259 260 /// operator== - Determine whether the specified names are identical.. 261 friend bool operator==(DeclarationName LHS, DeclarationName RHS) { 262 return LHS.Ptr == RHS.Ptr; 263 } 264 265 /// operator!= - Determine whether the specified names are different. 266 friend bool operator!=(DeclarationName LHS, DeclarationName RHS) { 267 return LHS.Ptr != RHS.Ptr; 268 } 269 270 static DeclarationName getEmptyMarker() { 271 return DeclarationName(uintptr_t(-1)); 272 } 273 274 static DeclarationName getTombstoneMarker() { 275 return DeclarationName(uintptr_t(-2)); 276 } 277 278 static int compare(DeclarationName LHS, DeclarationName RHS); 279 280 void dump() const; 281}; 282 283/// Ordering on two declaration names. If both names are identifiers, 284/// this provides a lexicographical ordering. 285inline bool operator<(DeclarationName LHS, DeclarationName RHS) { 286 return DeclarationName::compare(LHS, RHS) < 0; 287} 288 289/// Ordering on two declaration names. If both names are identifiers, 290/// this provides a lexicographical ordering. 291inline bool operator>(DeclarationName LHS, DeclarationName RHS) { 292 return DeclarationName::compare(LHS, RHS) > 0; 293} 294 295/// Ordering on two declaration names. If both names are identifiers, 296/// this provides a lexicographical ordering. 297inline bool operator<=(DeclarationName LHS, DeclarationName RHS) { 298 return DeclarationName::compare(LHS, RHS) <= 0; 299} 300 301/// Ordering on two declaration names. If both names are identifiers, 302/// this provides a lexicographical ordering. 303inline bool operator>=(DeclarationName LHS, DeclarationName RHS) { 304 return DeclarationName::compare(LHS, RHS) >= 0; 305} 306 307/// DeclarationNameTable - Used to store and retrieve DeclarationName 308/// instances for the various kinds of declaration names, e.g., normal 309/// identifiers, C++ constructor names, etc. This class contains 310/// uniqued versions of each of the C++ special names, which can be 311/// retrieved using its member functions (e.g., 312/// getCXXConstructorName). 313class DeclarationNameTable { 314 void *CXXSpecialNamesImpl; // Actually a FoldingSet<CXXSpecialName> * 315 CXXOperatorIdName *CXXOperatorNames; // Operator names 316 void *CXXLiteralOperatorNames; // Actually a FoldingSet<...> * 317 318 DeclarationNameTable(const DeclarationNameTable&); // NONCOPYABLE 319 DeclarationNameTable& operator=(const DeclarationNameTable&); // NONCOPYABLE 320 321public: 322 DeclarationNameTable(); 323 ~DeclarationNameTable(); 324 325 /// getIdentifier - Create a declaration name that is a simple 326 /// identifier. 327 DeclarationName getIdentifier(const IdentifierInfo *ID) { 328 return DeclarationName(ID); 329 } 330 331 /// getCXXConstructorName - Returns the name of a C++ constructor 332 /// for the given Type. 333 DeclarationName getCXXConstructorName(CanQualType Ty) { 334 return getCXXSpecialName(DeclarationName::CXXConstructorName, Ty); 335 } 336 337 /// getCXXDestructorName - Returns the name of a C++ destructor 338 /// for the given Type. 339 DeclarationName getCXXDestructorName(CanQualType Ty) { 340 return getCXXSpecialName(DeclarationName::CXXDestructorName, Ty); 341 } 342 343 /// getCXXConversionFunctionName - Returns the name of a C++ 344 /// conversion function for the given Type. 345 DeclarationName getCXXConversionFunctionName(CanQualType Ty) { 346 return getCXXSpecialName(DeclarationName::CXXConversionFunctionName, Ty); 347 } 348 349 /// getCXXSpecialName - Returns a declaration name for special kind 350 /// of C++ name, e.g., for a constructor, destructor, or conversion 351 /// function. 352 DeclarationName getCXXSpecialName(DeclarationName::NameKind Kind, 353 CanQualType Ty); 354 355 /// getCXXOperatorName - Get the name of the overloadable C++ 356 /// operator corresponding to Op. 357 DeclarationName getCXXOperatorName(OverloadedOperatorKind Op); 358 359 /// getCXXLiteralOperatorName - Get the name of the literal operator function 360 /// with II as the identifier. 361 DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II); 362}; 363 364/// Insertion operator for diagnostics. This allows sending DeclarationName's 365/// into a diagnostic with <<. 366inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, 367 DeclarationName N) { 368 DB.AddTaggedVal(N.getAsOpaqueInteger(), 369 Diagnostic::ak_declarationname); 370 return DB; 371} 372 373/// Insertion operator for partial diagnostics. This allows binding 374/// DeclarationName's into a partial diagnostic with <<. 375inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, 376 DeclarationName N) { 377 PD.AddTaggedVal(N.getAsOpaqueInteger(), 378 Diagnostic::ak_declarationname); 379 return PD; 380} 381 382} // end namespace clang 383 384namespace llvm { 385/// Define DenseMapInfo so that DeclarationNames can be used as keys 386/// in DenseMap and DenseSets. 387template<> 388struct DenseMapInfo<clang::DeclarationName> { 389 static inline clang::DeclarationName getEmptyKey() { 390 return clang::DeclarationName::getEmptyMarker(); 391 } 392 393 static inline clang::DeclarationName getTombstoneKey() { 394 return clang::DeclarationName::getTombstoneMarker(); 395 } 396 397 static unsigned getHashValue(clang::DeclarationName); 398 399 static inline bool 400 isEqual(clang::DeclarationName LHS, clang::DeclarationName RHS) { 401 return LHS == RHS; 402 } 403}; 404 405template <> 406struct isPodLike<clang::DeclarationName> { static const bool value = true; }; 407 408} // end namespace llvm 409 410#endif 411