contrib/llvm/tools/clang/include/clang/AST/DeclarationName.h

   1 //===-- DeclarationName.h - Representation of declaration names -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares the DeclarationName and DeclarationNameTable classes.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 #ifndef LLVM_CLANG_AST_DECLARATIONNAME_H
  14 #define LLVM_CLANG_AST_DECLARATIONNAME_H
  15
  16 #include "clang/Basic/IdentifierTable.h"
  17 #include "clang/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