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