contrib/llvm/tools/clang/include/clang/AST/DeclarationName.h

   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
  21 namespace llvm {
  22   template <typename T> struct DenseMapInfo;
  23 }
  24
  25 namespace clang {
  26   class CXXSpecialName;
  27   class CXXOperatorIdName;
  28   class CXXLiteralOperatorIdName;
  29   class DeclarationNameExtra;
  30   class IdentifierInfo;
  31   class MultiKeywordSelector;
  32   class UsingDirectiveDecl;
  33   class TypeSourceInfo;
  34
  35 /// DeclarationName - The name of a declaration. In the common case,
  36 /// this just stores an IdentifierInfo pointer to a normal
  37 /// name. However, it also provides encodings for Objective-C
  38 /// selectors (optimizing zero- and one-argument selectors, which make
  39 /// up 78% percent of all selectors in Cocoa.h) and special C++ names
  40 /// for constructors, destructors, and conversion functions.
  41 class DeclarationName {
  42 public:
  43   /// NameKind - The kind of name this object contains.
  44   enum NameKind {
  45     Identifier,
  46     ObjCZeroArgSelector,
  47     ObjCOneArgSelector,
  48     ObjCMultiArgSelector,
  49     CXXConstructorName,
  50     CXXDestructorName,
  51     CXXConversionFunctionName,
  52     CXXOperatorName,
  53     CXXLiteralOperatorName,
  54     CXXUsingDirective
  55   };
  56
  57 private:
  58   /// StoredNameKind - The kind of name that is actually stored in the
  59   /// upper bits of the Ptr field. This is only used internally.
  60   enum StoredNameKind {
  61     StoredIdentifier = 0,
  62     StoredObjCZeroArgSelector,
  63     StoredObjCOneArgSelector,
  64     StoredDeclarationNameExtra,
  65     PtrMask = 0x03
  66   };
  67
  68   /// Ptr - The lowest two bits are used to express what kind of name
  69   /// we're actually storing, using the values of NameKind. Depending
  70   /// on the kind of name this is, the upper bits of Ptr may have one
  71   /// of several different meanings:
  72   ///
  73   ///   StoredIdentifier - The name is a normal identifier, and Ptr is
  74   ///   a normal IdentifierInfo pointer.
  75   ///
  76   ///   StoredObjCZeroArgSelector - The name is an Objective-C
  77   ///   selector with zero arguments, and Ptr is an IdentifierInfo
  78   ///   pointer pointing to the selector name.
  79   ///
  80   ///   StoredObjCOneArgSelector - The name is an Objective-C selector
  81   ///   with one argument, and Ptr is an IdentifierInfo pointer
  82   ///   pointing to the selector name.
  83   ///
  84   ///   StoredDeclarationNameExtra - Ptr is actually a pointer to a
  85   ///   DeclarationNameExtra structure, whose first value will tell us
  86   ///   whether this is an Objective-C selector, C++ operator-id name,
  87   ///   or special C++ name.
  88   uintptr_t Ptr;
  89
  90   /// getStoredNameKind - Return the kind of object that is stored in
  91   /// Ptr.
  92   StoredNameKind getStoredNameKind() const {
  93     return static_cast<StoredNameKind>(Ptr & PtrMask);
  94   }
  95
  96   /// getExtra - Get the "extra" information associated with this
  97   /// multi-argument selector or C++ special name.
  98   DeclarationNameExtra *getExtra() const {
  99     assert(getStoredNameKind() == StoredDeclarationNameExtra &&
 100            "Declaration name does not store an Extra structure");
 101     return reinterpret_cast<DeclarationNameExtra *>(Ptr & ~PtrMask);
 102   }
 103
 104   /// getAsCXXSpecialName - If the stored pointer is actually a
 105   /// CXXSpecialName, returns a pointer to it. Otherwise, returns
 106   /// a NULL pointer.
 107   CXXSpecialName *getAsCXXSpecialName() const {
 108     if (getNameKind() >= CXXConstructorName &&
 109         getNameKind() <= CXXConversionFunctionName)
 110       return reinterpret_cast<CXXSpecialName *>(Ptr & ~PtrMask);
 111     return 0;
 112   }
 113
 114   /// getAsCXXOperatorIdName
 115   CXXOperatorIdName *getAsCXXOperatorIdName() const {
 116     if (getNameKind() == CXXOperatorName)
 117       return reinterpret_cast<CXXOperatorIdName *>(Ptr & ~PtrMask);
 118     return 0;
 119   }
 120
 121   CXXLiteralOperatorIdName *getAsCXXLiteralOperatorIdName() const {
 122     if (getNameKind() == CXXLiteralOperatorName)
 123       return reinterpret_cast<CXXLiteralOperatorIdName *>(Ptr & ~PtrMask);
 124     return 0;
 125   }
 126
 127   // Construct a declaration name from the name of a C++ constructor,
 128   // destructor, or conversion function.
 129   DeclarationName(CXXSpecialName *Name)
 130     : Ptr(reinterpret_cast<uintptr_t>(Name)) {
 131     assert((Ptr & PtrMask) == 0 && "Improperly aligned CXXSpecialName");
 132     Ptr |= StoredDeclarationNameExtra;
 133   }
 134
 135   // Construct a declaration name from the name of a C++ overloaded
 136   // operator.
 137   DeclarationName(CXXOperatorIdName *Name)
 138     : Ptr(reinterpret_cast<uintptr_t>(Name)) {
 139     assert((Ptr & PtrMask) == 0 && "Improperly aligned CXXOperatorId");
 140     Ptr |= StoredDeclarationNameExtra;
 141   }
 142
 143   DeclarationName(CXXLiteralOperatorIdName *Name)
 144     : Ptr(reinterpret_cast<uintptr_t>(Name)) {
 145     assert((Ptr & PtrMask) == 0 && "Improperly aligned CXXLiteralOperatorId");
 146     Ptr |= StoredDeclarationNameExtra;
 147   }
 148
 149   /// Construct a declaration name from a raw pointer.
 150   DeclarationName(uintptr_t Ptr) : Ptr(Ptr) { }
 151
 152   friend class DeclarationNameTable;
 153   friend class NamedDecl;
 154
 155   /// getFETokenInfoAsVoid - Retrieves the front end-specified pointer
 156   /// for this name as a void pointer.
 157   void *getFETokenInfoAsVoid() const;
 158
 159 public:
 160   /// DeclarationName - Used to create an empty selector.
 161   DeclarationName() : Ptr(0) { }
 162
 163   // Construct a declaration name from an IdentifierInfo *.
 164   DeclarationName(const IdentifierInfo *II)
 165     : Ptr(reinterpret_cast<uintptr_t>(II)) {
 166     assert((Ptr & PtrMask) == 0 && "Improperly aligned IdentifierInfo");
 167   }
 168
 169   // Construct a declaration name from an Objective-C selector.
 170   DeclarationName(Selector Sel);
 171
 172   /// getUsingDirectiveName - Return name for all using-directives.
 173   static DeclarationName getUsingDirectiveName();
 174
 175   // operator bool() - Evaluates true when this declaration name is
 176   // non-empty.
 177   operator bool() const {
 178     return ((Ptr & PtrMask) != 0) ||
 179            (reinterpret_cast<IdentifierInfo *>(Ptr & ~PtrMask));
 180   }
 181
 182   /// Predicate functions for querying what type of name this is.
 183   bool isIdentifier() const { return getStoredNameKind() == StoredIdentifier; }
 184   bool isObjCZeroArgSelector() const {
 185     return getStoredNameKind() == StoredObjCZeroArgSelector;
 186   }
 187   bool isObjCOneArgSelector() const {
 188     return getStoredNameKind() == StoredObjCOneArgSelector;
 189   }
 190
 191   /// getNameKind - Determine what kind of name this is.
 192   NameKind getNameKind() const;
 193
 194   /// \brief Determines whether the name itself is dependent, e.g., because it
 195   /// involves a C++ type that is itself dependent.
 196   ///
 197   /// Note that this does not capture all of the notions of "dependent name",
 198   /// because an identifier can be a dependent name if it is used as the
 199   /// callee in a call expression with dependent arguments.
 200   bool isDependentName() const;
 201
 202   /// getNameAsString - Retrieve the human-readable string for this name.
 203   std::string getAsString() const;
 204
 205   /// printName - Print the human-readable name to a stream.
 206   void printName(raw_ostream &OS) const;
 207
 208   /// getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in
 209   /// this declaration name, or NULL if this declaration name isn't a
 210   /// simple identifier.
 211   IdentifierInfo *getAsIdentifierInfo() const {
 212     if (isIdentifier())
 213       return reinterpret_cast<IdentifierInfo *>(Ptr);
 214     return 0;
 215   }
 216
 217   /// getAsOpaqueInteger - Get the representation of this declaration
 218   /// name as an opaque integer.
 219   uintptr_t getAsOpaqueInteger() const { return Ptr; }
 220
 221   /// getAsOpaquePtr - Get the representation of this declaration name as
 222   /// an opaque pointer.
 223   void *getAsOpaquePtr() const { return reinterpret_cast<void*>(Ptr); }
 224
 225   static DeclarationName getFromOpaquePtr(void *P) {
 226     DeclarationName N;
 227     N.Ptr = reinterpret_cast<uintptr_t> (P);
 228     return N;
 229   }
 230
 231   static DeclarationName getFromOpaqueInteger(uintptr_t P) {
 232     DeclarationName N;
 233     N.Ptr = P;
 234     return N;
 235   }
 236
 237   /// getCXXNameType - If this name is one of the C++ names (of a
 238   /// constructor, destructor, or conversion function), return the
 239   /// type associated with that name.
 240   QualType getCXXNameType() const;
 241
 242   /// getCXXOverloadedOperator - If this name is the name of an
 243   /// overloadable operator in C++ (e.g., @c operator+), retrieve the
 244   /// kind of overloaded operator.
 245   OverloadedOperatorKind getCXXOverloadedOperator() const;
 246
 247   /// getCXXLiteralIdentifier - If this name is the name of a literal
 248   /// operator, retrieve the identifier associated with it.
 249   IdentifierInfo *getCXXLiteralIdentifier() const;
 250
 251   /// getObjCSelector - Get the Objective-C selector stored in this
 252   /// declaration name.
 253   Selector getObjCSelector() const;
 254
 255   /// getFETokenInfo/setFETokenInfo - The language front-end is
 256   /// allowed to associate arbitrary metadata with some kinds of
 257   /// declaration names, including normal identifiers and C++
 258   /// constructors, destructors, and conversion functions.
 259   template<typename T>
 260   T *getFETokenInfo() const { return static_cast<T*>(getFETokenInfoAsVoid()); }
 261
 262   void setFETokenInfo(void *T);
 263
 264   /// operator== - Determine whether the specified names are identical..
 265   friend bool operator==(DeclarationName LHS, DeclarationName RHS) {
 266     return LHS.Ptr == RHS.Ptr;
 267   }
 268
 269   /// operator!= - Determine whether the specified names are different.
 270   friend bool operator!=(DeclarationName LHS, DeclarationName RHS) {
 271     return LHS.Ptr != RHS.Ptr;
 272   }
 273
 274   static DeclarationName getEmptyMarker() {
 275     return DeclarationName(uintptr_t(-1));
 276   }
 277
 278   static DeclarationName getTombstoneMarker() {
 279     return DeclarationName(uintptr_t(-2));
 280   }
 281
 282   static int compare(DeclarationName LHS, DeclarationName RHS);
 283
 284   void dump() const;
 285 };
 286
 287 /// Ordering on two declaration names. If both names are identifiers,
 288 /// this provides a lexicographical ordering.
 289 inline bool operator<(DeclarationName LHS, DeclarationName RHS) {
 290   return DeclarationName::compare(LHS, RHS) < 0;
 291 }
 292
 293 /// Ordering on two declaration names. If both names are identifiers,
 294 /// this provides a lexicographical ordering.
 295 inline bool operator>(DeclarationName LHS, DeclarationName RHS) {
 296   return DeclarationName::compare(LHS, RHS) > 0;
 297 }
 298
 299 /// Ordering on two declaration names. If both names are identifiers,
 300 /// this provides a lexicographical ordering.
 301 inline bool operator<=(DeclarationName LHS, DeclarationName RHS) {
 302   return DeclarationName::compare(LHS, RHS) <= 0;
 303 }
 304
 305 /// Ordering on two declaration names. If both names are identifiers,
 306 /// this provides a lexicographical ordering.
 307 inline bool operator>=(DeclarationName LHS, DeclarationName RHS) {
 308   return DeclarationName::compare(LHS, RHS) >= 0;
 309 }
 310
 311 /// DeclarationNameTable - Used to store and retrieve DeclarationName
 312 /// instances for the various kinds of declaration names, e.g., normal
 313 /// identifiers, C++ constructor names, etc. This class contains
 314 /// uniqued versions of each of the C++ special names, which can be
 315 /// retrieved using its member functions (e.g.,
 316 /// getCXXConstructorName).
 317 class DeclarationNameTable {
 318   const ASTContext &Ctx;
 319   void *CXXSpecialNamesImpl; // Actually a FoldingSet<CXXSpecialName> *
 320   CXXOperatorIdName *CXXOperatorNames; // Operator names
 321   void *CXXLiteralOperatorNames; // Actually a CXXOperatorIdName*
 322
 323   DeclarationNameTable(const DeclarationNameTable&);            // NONCOPYABLE
 324   DeclarationNameTable& operator=(const DeclarationNameTable&); // NONCOPYABLE
 325
 326 public:
 327   DeclarationNameTable(const ASTContext &C);
 328   ~DeclarationNameTable();
 329
 330   /// getIdentifier - Create a declaration name that is a simple
 331   /// identifier.
 332   DeclarationName getIdentifier(const IdentifierInfo *ID) {
 333     return DeclarationName(ID);
 334   }
 335
 336   /// getCXXConstructorName - Returns the name of a C++ constructor
 337   /// for the given Type.
 338   DeclarationName getCXXConstructorName(CanQualType Ty) {
 339     return getCXXSpecialName(DeclarationName::CXXConstructorName,
 340                              Ty.getUnqualifiedType());
 341   }
 342
 343   /// getCXXDestructorName - Returns the name of a C++ destructor
 344   /// for the given Type.
 345   DeclarationName getCXXDestructorName(CanQualType Ty) {
 346     return getCXXSpecialName(DeclarationName::CXXDestructorName,
 347                              Ty.getUnqualifiedType());
 348   }
 349
 350   /// getCXXConversionFunctionName - Returns the name of a C++
 351   /// conversion function for the given Type.
 352   DeclarationName getCXXConversionFunctionName(CanQualType Ty) {
 353     return getCXXSpecialName(DeclarationName::CXXConversionFunctionName, Ty);
 354   }
 355
 356   /// getCXXSpecialName - Returns a declaration name for special kind
 357   /// of C++ name, e.g., for a constructor, destructor, or conversion
 358   /// function.
 359   DeclarationName getCXXSpecialName(DeclarationName::NameKind Kind,
 360                                     CanQualType Ty);
 361
 362   /// getCXXOperatorName - Get the name of the overloadable C++
 363   /// operator corresponding to Op.
 364   DeclarationName getCXXOperatorName(OverloadedOperatorKind Op);
 365
 366   /// getCXXLiteralOperatorName - Get the name of the literal operator function
 367   /// with II as the identifier.
 368   DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II);
 369 };
 370
 371 /// DeclarationNameLoc - Additional source/type location info
 372 /// for a declaration name. Needs a DeclarationName in order
 373 /// to be interpreted correctly.
 374 struct DeclarationNameLoc {
 375   union {
 376     // The source location for identifier stored elsewhere.
 377     // struct {} Identifier;
 378
 379     // Type info for constructors, destructors and conversion functions.
 380     // Locations (if any) for the tilde (destructor) or operator keyword
 381     // (conversion) are stored elsewhere.
 382     struct {
 383       TypeSourceInfo* TInfo;
 384     } NamedType;
 385
 386     // The location (if any) of the operator keyword is stored elsewhere.
 387     struct {
 388       unsigned BeginOpNameLoc;
 389       unsigned EndOpNameLoc;
 390     } CXXOperatorName;
 391
 392     // The location (if any) of the operator keyword is stored elsewhere.
 393     struct {
 394       unsigned OpNameLoc;
 395     } CXXLiteralOperatorName;
 396
 397     // struct {} CXXUsingDirective;
 398     // struct {} ObjCZeroArgSelector;
 399     // struct {} ObjCOneArgSelector;
 400     // struct {} ObjCMultiArgSelector;
 401   };
 402
 403   DeclarationNameLoc(DeclarationName Name);
 404   // FIXME: this should go away once all DNLocs are properly initialized.
 405   DeclarationNameLoc() { memset((void*) this, 0, sizeof(*this)); }
 406 }; // struct DeclarationNameLoc
 407
 408
 409 /// DeclarationNameInfo - A collector data type for bundling together
 410 /// a DeclarationName and the correspnding source/type location info.
 411 struct DeclarationNameInfo {
 412 private:
 413   /// Name - The declaration name, also encoding name kind.
 414   DeclarationName Name;
 415   /// Loc - The main source location for the declaration name.
 416   SourceLocation NameLoc;
 417   /// Info - Further source/type location info for special kinds of names.
 418   DeclarationNameLoc LocInfo;
 419
 420 public:
 421   // FIXME: remove it.
 422   DeclarationNameInfo() {}
 423
 424   DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc)
 425     : Name(Name), NameLoc(NameLoc), LocInfo(Name) {}
 426
 427   DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc,
 428                       DeclarationNameLoc LocInfo)
 429     : Name(Name), NameLoc(NameLoc), LocInfo(LocInfo) {}
 430
 431   /// getName - Returns the embedded declaration name.
 432   DeclarationName getName() const { return Name; }
 433   /// setName - Sets the embedded declaration name.
 434   void setName(DeclarationName N) { Name = N; }
 435
 436   /// getLoc - Returns the main location of the declaration name.
 437   SourceLocation getLoc() const { return NameLoc; }
 438   /// setLoc - Sets the main location of the declaration name.
 439   void setLoc(SourceLocation L) { NameLoc = L; }
 440
 441   const DeclarationNameLoc &getInfo() const { return LocInfo; }
 442   DeclarationNameLoc &getInfo() { return LocInfo; }
 443   void setInfo(const DeclarationNameLoc &Info) { LocInfo = Info; }
 444
 445   /// getNamedTypeInfo - Returns the source type info associated to
 446   /// the name. Assumes it is a constructor, destructor or conversion.
 447   TypeSourceInfo *getNamedTypeInfo() const {
 448     assert(Name.getNameKind() == DeclarationName::CXXConstructorName ||
 449            Name.getNameKind() == DeclarationName::CXXDestructorName ||
 450            Name.getNameKind() == DeclarationName::CXXConversionFunctionName);
 451     return LocInfo.NamedType.TInfo;
 452   }
 453   /// setNamedTypeInfo - Sets the source type info associated to
 454   /// the name. Assumes it is a constructor, destructor or conversion.
 455   void setNamedTypeInfo(TypeSourceInfo *TInfo) {
 456     assert(Name.getNameKind() == DeclarationName::CXXConstructorName ||
 457            Name.getNameKind() == DeclarationName::CXXDestructorName ||
 458            Name.getNameKind() == DeclarationName::CXXConversionFunctionName);
 459     LocInfo.NamedType.TInfo = TInfo;
 460   }
 461
 462   /// getCXXOperatorNameRange - Gets the range of the operator name
 463   /// (without the operator keyword). Assumes it is a (non-literal) operator.
 464   SourceRange getCXXOperatorNameRange() const {
 465     assert(Name.getNameKind() == DeclarationName::CXXOperatorName);
 466     return SourceRange(
 467      SourceLocation::getFromRawEncoding(LocInfo.CXXOperatorName.BeginOpNameLoc),
 468      SourceLocation::getFromRawEncoding(LocInfo.CXXOperatorName.EndOpNameLoc)
 469                        );
 470   }
 471   /// setCXXOperatorNameRange - Sets the range of the operator name
 472   /// (without the operator keyword). Assumes it is a C++ operator.
 473   void setCXXOperatorNameRange(SourceRange R) {
 474     assert(Name.getNameKind() == DeclarationName::CXXOperatorName);
 475     LocInfo.CXXOperatorName.BeginOpNameLoc = R.getBegin().getRawEncoding();
 476     LocInfo.CXXOperatorName.EndOpNameLoc = R.getEnd().getRawEncoding();
 477   }
 478
 479   /// getCXXLiteralOperatorNameLoc - Returns the location of the literal
 480   /// operator name (not the operator keyword).
 481   /// Assumes it is a literal operator.
 482   SourceLocation getCXXLiteralOperatorNameLoc() const {
 483     assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);
 484     return SourceLocation::
 485       getFromRawEncoding(LocInfo.CXXLiteralOperatorName.OpNameLoc);
 486   }
 487   /// setCXXLiteralOperatorNameLoc - Sets the location of the literal
 488   /// operator name (not the operator keyword).
 489   /// Assumes it is a literal operator.
 490   void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {
 491     assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);
 492     LocInfo.CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding();
 493   }
 494
 495   /// \brief Determine whether this name involves a template parameter.
 496   bool isInstantiationDependent() const;
 497
 498   /// \brief Determine whether this name contains an unexpanded
 499   /// parameter pack.
 500   bool containsUnexpandedParameterPack() const;
 501
 502   /// getAsString - Retrieve the human-readable string for this name.
 503   std::string getAsString() const;
 504
 505   /// printName - Print the human-readable name to a stream.
 506   void printName(raw_ostream &OS) const;
 507
 508   /// getBeginLoc - Retrieve the location of the first token.
 509   SourceLocation getBeginLoc() const { return NameLoc; }
 510   /// getEndLoc - Retrieve the location of the last token.
 511   SourceLocation getEndLoc() const;
 512   /// getSourceRange - The range of the declaration name.
 513   SourceRange getSourceRange() const {
 514     return SourceRange(getBeginLoc(), getEndLoc());
 515   }
 516 };
 517
 518 /// Insertion operator for diagnostics.  This allows sending DeclarationName's
 519 /// into a diagnostic with <<.
 520 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
 521                                            DeclarationName N) {
 522   DB.AddTaggedVal(N.getAsOpaqueInteger(),
 523                   DiagnosticsEngine::ak_declarationname);
 524   return DB;
 525 }
 526
 527 /// Insertion operator for partial diagnostics.  This allows binding
 528 /// DeclarationName's into a partial diagnostic with <<.
 529 inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 530                                            DeclarationName N) {
 531   PD.AddTaggedVal(N.getAsOpaqueInteger(),
 532                   DiagnosticsEngine::ak_declarationname);
 533   return PD;
 534 }
 535
 536 inline raw_ostream &operator<<(raw_ostream &OS,
 537                                      DeclarationNameInfo DNInfo) {
 538   DNInfo.printName(OS);
 539   return OS;
 540 }
 541
 542 }  // end namespace clang
 543
 544 namespace llvm {
 545 /// Define DenseMapInfo so that DeclarationNames can be used as keys
 546 /// in DenseMap and DenseSets.
 547 template<>
 548 struct DenseMapInfo<clang::DeclarationName> {
 549   static inline clang::DeclarationName getEmptyKey() {
 550     return clang::DeclarationName::getEmptyMarker();
 551   }
 552
 553   static inline clang::DeclarationName getTombstoneKey() {
 554     return clang::DeclarationName::getTombstoneMarker();
 555   }
 556
 557   static unsigned getHashValue(clang::DeclarationName);
 558
 559   static inline bool
 560   isEqual(clang::DeclarationName LHS, clang::DeclarationName RHS) {
 561     return LHS == RHS;
 562   }
 563 };
 564
 565 template <>
 566 struct isPodLike<clang::DeclarationName> { static const bool value = true; };
 567
 568 }  // end namespace llvm
 569
 570 #endif