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