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