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