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