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