DeclarationName.h source code [clang_source_code/include/clang/AST/DeclarationName.h]

1	//===- DeclarationName.h - Representation of declaration names --- C++ --===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file declares the DeclarationName and DeclarationNameTable classes.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#ifndef LLVM_CLANG_AST_DECLARATIONNAME_H
14	#define LLVM_CLANG_AST_DECLARATIONNAME_H
15
16	#include "clang/AST/Type.h"
17	#include "clang/Basic/Diagnostic.h"
18	#include "clang/Basic/IdentifierTable.h"
19	#include "clang/Basic/OperatorKinds.h"
20	#include "clang/Basic/PartialDiagnostic.h"
21	#include "clang/Basic/SourceLocation.h"
22	#include "llvm/ADT/DenseMapInfo.h"
23	#include "llvm/ADT/FoldingSet.h"
24	#include "llvm/Support/Compiler.h"
25	#include "llvm/Support/type_traits.h"
26	#include <cassert>
27	#include <cstdint>
28	#include <cstring>
29	#include <string>
30
31	namespace clang {
32
33	class ASTContext;
34	template <typename> class CanQual;
35	class DeclarationName;
36	class DeclarationNameTable;
37	class MultiKeywordSelector;
38	struct PrintingPolicy;
39	class TemplateDecl;
40	class TypeSourceInfo;
41	class UsingDirectiveDecl;
42
43	using CanQualType = CanQual<Type>;
44
45	namespace detail {
46
47	/// CXXSpecialNameExtra records the type associated with one of the "special"
48	/// kinds of declaration names in C++, e.g., constructors, destructors, and
49	/// conversion functions. Note that CXXSpecialName is used for C++ constructor,
50	/// destructor and conversion functions, but the actual kind is not stored in
51	/// CXXSpecialName. Instead we use three different FoldingSet<CXXSpecialName>
52	/// in DeclarationNameTable.
53	class alignas(IdentifierInfoAlignment) CXXSpecialNameExtra
54	: public llvm::FoldingSetNode {
55	friend class clang::DeclarationName;
56	friend class clang::DeclarationNameTable;
57
58	/// The type associated with this declaration name.
59	QualType Type;
60
61	/// Extra information associated with this declaration name that
62	/// can be used by the front end. All bits are really needed
63	/// so it is not possible to stash something in the low order bits.
64	void *FETokenInfo;
65
66	CXXSpecialNameExtra(QualType QT) : Type(QT), FETokenInfo(nullptr) {}
67
68	public:
69	void Profile(llvm::FoldingSetNodeID &ID) {
70	ID.AddPointer(Type.getAsOpaquePtr());
71	}
72	};
73
74	/// Contains extra information for the name of a C++ deduction guide.
75	class alignas(IdentifierInfoAlignment) CXXDeductionGuideNameExtra
76	: public detail::DeclarationNameExtra,
77	public llvm::FoldingSetNode {
78	friend class clang::DeclarationName;
79	friend class clang::DeclarationNameTable;
80
81	/// The template named by the deduction guide.
82	TemplateDecl *Template;
83
84	/// Extra information associated with this operator name that
85	/// can be used by the front end. All bits are really needed
86	/// so it is not possible to stash something in the low order bits.
87	void *FETokenInfo;
88
89	CXXDeductionGuideNameExtra(TemplateDecl *TD)
90	: DeclarationNameExtra(CXXDeductionGuideName), Template(TD),
91	FETokenInfo(nullptr) {}
92
93	public:
94	void Profile(llvm::FoldingSetNodeID &ID) { ID.AddPointer(Template); }
95	};
96
97	/// Contains extra information for the name of an overloaded operator
98	/// in C++, such as "operator+. This do not includes literal or conversion
99	/// operators. For literal operators see CXXLiteralOperatorIdName and for
100	/// conversion operators see CXXSpecialNameExtra.
101	class alignas(IdentifierInfoAlignment) CXXOperatorIdName {
102	friend class clang::DeclarationName;
103	friend class clang::DeclarationNameTable;
104
105	/// The kind of this operator.
106	OverloadedOperatorKind Kind = OO_None;
107
108	/// Extra information associated with this operator name that
109	/// can be used by the front end. All bits are really needed
110	/// so it is not possible to stash something in the low order bits.
111	void *FETokenInfo = nullptr;
112	};
113
114	/// Contains the actual identifier that makes up the
115	/// name of a C++ literal operator.
116	class alignas(IdentifierInfoAlignment) CXXLiteralOperatorIdName
117	: public detail::DeclarationNameExtra,
118	public llvm::FoldingSetNode {
119	friend class clang::DeclarationName;
120	friend class clang::DeclarationNameTable;
121
122	IdentifierInfo *ID;
123
124	/// Extra information associated with this operator name that
125	/// can be used by the front end. All bits are really needed
126	/// so it is not possible to stash something in the low order bits.
127	void *FETokenInfo;
128
129	CXXLiteralOperatorIdName(IdentifierInfo *II)
130	: DeclarationNameExtra(CXXLiteralOperatorName), ID(II),
131	FETokenInfo(nullptr) {}
132
133	public:
134	void Profile(llvm::FoldingSetNodeID &FSID) { FSID.AddPointer(ID); }
135	};
136
137	} // namespace detail
138
139	/// The name of a declaration. In the common case, this just stores
140	/// an IdentifierInfo pointer to a normal name. However, it also provides
141	/// encodings for Objective-C selectors (optimizing zero- and one-argument
142	/// selectors, which make up 78% percent of all selectors in Cocoa.h),
143	/// special C++ names for constructors, destructors, and conversion functions,
144	/// and C++ overloaded operators.
145	class DeclarationName {
146	friend class DeclarationNameTable;
147	friend class NamedDecl;
148
149	/// StoredNameKind represent the kind of name that is actually stored in the
150	/// upper bits of the Ptr field. This is only used internally.
151	///
152	/// NameKind, StoredNameKind, and DeclarationNameExtra::ExtraKind
153	/// must satisfy the following properties. These properties enable
154	/// efficient conversion between the various kinds.
155	///
156	/// * The first seven enumerators of StoredNameKind must have the same
157	/// numerical value as the first seven enumerators of NameKind.
158	/// This enable efficient conversion between the two enumerations
159	/// in the usual case.
160	///
161	/// * The enumerations values of DeclarationNameExtra::ExtraKind must start
162	/// at zero, and correspond to the numerical value of the first non-inline
163	/// enumeration values of NameKind minus an offset. This makes conversion
164	/// between DeclarationNameExtra::ExtraKind and NameKind possible with
165	/// a single addition/substraction.
166	///
167	/// * The enumeration values of Selector::IdentifierInfoFlag must correspond
168	/// to the relevant enumeration values of StoredNameKind.
169	/// More specifically:
170	/// * ZeroArg == StoredObjCZeroArgSelector,
171	/// * OneArg == StoredObjCOneArgSelector,
172	/// * MultiArg == StoredDeclarationNameExtra
173	///
174	/// * PtrMask must mask the low 3 bits of Ptr.
175	enum StoredNameKind {
176	StoredIdentifier = 0,
177	StoredObjCZeroArgSelector = Selector::ZeroArg,
178	StoredObjCOneArgSelector = Selector::OneArg,
179	StoredCXXConstructorName = 3,
180	StoredCXXDestructorName = 4,
181	StoredCXXConversionFunctionName = 5,
182	StoredCXXOperatorName = 6,
183	StoredDeclarationNameExtra = Selector::MultiArg,
184	PtrMask = 7,
185	UncommonNameKindOffset = 8
186	};
187
188	static_assert(alignof(IdentifierInfo) >= 8 &&
189	alignof(detail::DeclarationNameExtra) >= 8 &&
190	alignof(detail::CXXSpecialNameExtra) >= 8 &&
191	alignof(detail::CXXOperatorIdName) >= 8 &&
192	alignof(detail::CXXDeductionGuideNameExtra) >= 8 &&
193	alignof(detail::CXXLiteralOperatorIdName) >= 8,
194	"The various classes that DeclarationName::Ptr can point to"
195	" must be at least aligned to 8 bytes!");
196
197	public:
198	/// The kind of the name stored in this DeclarationName.
199	/// The first 7 enumeration values are stored inline and correspond
200	/// to frequently used kinds. The rest is stored in DeclarationNameExtra
201	/// and correspond to infrequently used kinds.
202	enum NameKind {
203	Identifier = StoredIdentifier,
204	ObjCZeroArgSelector = StoredObjCZeroArgSelector,
205	ObjCOneArgSelector = StoredObjCOneArgSelector,
206	CXXConstructorName = StoredCXXConstructorName,
207	CXXDestructorName = StoredCXXDestructorName,
208	CXXConversionFunctionName = StoredCXXConversionFunctionName,
209	CXXOperatorName = StoredCXXOperatorName,
210	CXXDeductionGuideName = UncommonNameKindOffset +
211	detail::DeclarationNameExtra::CXXDeductionGuideName,
212	CXXLiteralOperatorName =
213	UncommonNameKindOffset +
214	detail::DeclarationNameExtra::CXXLiteralOperatorName,
215	CXXUsingDirective = UncommonNameKindOffset +
216	detail::DeclarationNameExtra::CXXUsingDirective,
217	ObjCMultiArgSelector = UncommonNameKindOffset +
218	detail::DeclarationNameExtra::ObjCMultiArgSelector
219	};
220
221	private:
222	/// The lowest three bits of Ptr are used to express what kind of name
223	/// we're actually storing, using the values of StoredNameKind. Depending
224	/// on the kind of name this is, the upper bits of Ptr may have one
225	/// of several different meanings:
226	///
227	/// StoredIdentifier - The name is a normal identifier, and Ptr is
228	/// a normal IdentifierInfo pointer.
229	///
230	/// StoredObjCZeroArgSelector - The name is an Objective-C
231	/// selector with zero arguments, and Ptr is an IdentifierInfo
232	/// pointer pointing to the selector name.
233	///
234	/// StoredObjCOneArgSelector - The name is an Objective-C selector
235	/// with one argument, and Ptr is an IdentifierInfo pointer
236	/// pointing to the selector name.
237	///
238	/// StoredCXXConstructorName - The name of a C++ constructor,
239	/// Ptr points to a CXXSpecialNameExtra.
240	///
241	/// StoredCXXDestructorName - The name of a C++ destructor,
242	/// Ptr points to a CXXSpecialNameExtra.
243	///
244	/// StoredCXXConversionFunctionName - The name of a C++ conversion function,
245	/// Ptr points to a CXXSpecialNameExtra.
246	///
247	/// StoredCXXOperatorName - The name of an overloaded C++ operator,
248	/// Ptr points to a CXXOperatorIdName.
249	///
250	/// StoredDeclarationNameExtra - Ptr is actually a pointer to a
251	/// DeclarationNameExtra structure, whose first value will tell us
252	/// whether this is an Objective-C selector, C++ deduction guide,
253	/// C++ literal operator, or C++ using directive.
254	uintptr_t Ptr = 0;
255
256	StoredNameKind getStoredNameKind() const {
257	return static_cast<StoredNameKind>(Ptr & PtrMask);
258	}
259
260	void getPtr() const { return reinterpret_cast<void >(Ptr & ~PtrMask); }
261
262	void setPtrAndKind(const void *P, StoredNameKind Kind) {
263	uintptr_t PAsInteger = reinterpret_cast<uintptr_t>(P);
264	(0) . __assert_fail ("(Kind & ~PtrMask) == 0 && \"Invalid StoredNameKind in setPtrAndKind!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 265, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert((Kind & ~PtrMask) == 0 &&
265	(0) . __assert_fail ("(Kind & ~PtrMask) == 0 && \"Invalid StoredNameKind in setPtrAndKind!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 265, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "Invalid StoredNameKind in setPtrAndKind!");
266	(0) . __assert_fail ("(PAsInteger & PtrMask) == 0 && \"Improperly aligned pointer in setPtrAndKind!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 267, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert((PAsInteger & PtrMask) == 0 &&
267	(0) . __assert_fail ("(PAsInteger & PtrMask) == 0 && \"Improperly aligned pointer in setPtrAndKind!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 267, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "Improperly aligned pointer in setPtrAndKind!");
268	Ptr = PAsInteger \| Kind;
269	}
270
271	/// Construct a declaration name from a DeclarationNameExtra.
272	DeclarationName(detail::DeclarationNameExtra *Name) {
273	setPtrAndKind(Name, StoredDeclarationNameExtra);
274	}
275
276	/// Construct a declaration name from a CXXSpecialNameExtra.
277	DeclarationName(detail::CXXSpecialNameExtra *Name,
278	StoredNameKind StoredKind) {
279	(0) . __assert_fail ("(StoredKind == StoredCXXConstructorName \|\| StoredKind == StoredCXXDestructorName \|\| StoredKind == StoredCXXConversionFunctionName) && \"Invalid StoredNameKind when constructing a DeclarationName\" \" from a CXXSpecialNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 283, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert((StoredKind == StoredCXXConstructorName \|\|
280	(0) . __assert_fail ("(StoredKind == StoredCXXConstructorName \|\| StoredKind == StoredCXXDestructorName \|\| StoredKind == StoredCXXConversionFunctionName) && \"Invalid StoredNameKind when constructing a DeclarationName\" \" from a CXXSpecialNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 283, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> StoredKind == StoredCXXDestructorName \|\|
281	(0) . __assert_fail ("(StoredKind == StoredCXXConstructorName \|\| StoredKind == StoredCXXDestructorName \|\| StoredKind == StoredCXXConversionFunctionName) && \"Invalid StoredNameKind when constructing a DeclarationName\" \" from a CXXSpecialNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 283, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> StoredKind == StoredCXXConversionFunctionName) &&
282	(0) . __assert_fail ("(StoredKind == StoredCXXConstructorName \|\| StoredKind == StoredCXXDestructorName \|\| StoredKind == StoredCXXConversionFunctionName) && \"Invalid StoredNameKind when constructing a DeclarationName\" \" from a CXXSpecialNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 283, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "Invalid StoredNameKind when constructing a DeclarationName"
283	(0) . __assert_fail ("(StoredKind == StoredCXXConstructorName \|\| StoredKind == StoredCXXDestructorName \|\| StoredKind == StoredCXXConversionFunctionName) && \"Invalid StoredNameKind when constructing a DeclarationName\" \" from a CXXSpecialNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 283, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> " from a CXXSpecialNameExtra!");
284	setPtrAndKind(Name, StoredKind);
285	}
286
287	/// Construct a DeclarationName from a CXXOperatorIdName.
288	DeclarationName(detail::CXXOperatorIdName *Name) {
289	setPtrAndKind(Name, StoredCXXOperatorName);
290	}
291
292	/// Assert that the stored pointer points to an IdentifierInfo and return it.
293	IdentifierInfo *castAsIdentifierInfo() const {
294	(0) . __assert_fail ("(getStoredNameKind() == StoredIdentifier) && \"DeclarationName does not store an IdentifierInfo!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 295, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert((getStoredNameKind() == StoredIdentifier) &&
295	(0) . __assert_fail ("(getStoredNameKind() == StoredIdentifier) && \"DeclarationName does not store an IdentifierInfo!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 295, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "DeclarationName does not store an IdentifierInfo!");
296	return static_cast<IdentifierInfo *>(getPtr());
297	}
298
299	/// Assert that the stored pointer points to a DeclarationNameExtra
300	/// and return it.
301	detail::DeclarationNameExtra *castAsExtra() const {
302	(0) . __assert_fail ("(getStoredNameKind() == StoredDeclarationNameExtra) && \"DeclarationName does not store an Extra structure!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 303, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert((getStoredNameKind() == StoredDeclarationNameExtra) &&
303	(0) . __assert_fail ("(getStoredNameKind() == StoredDeclarationNameExtra) && \"DeclarationName does not store an Extra structure!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 303, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "DeclarationName does not store an Extra structure!");
304	return static_cast<detail::DeclarationNameExtra *>(getPtr());
305	}
306
307	/// Assert that the stored pointer points to a CXXSpecialNameExtra
308	/// and return it.
309	detail::CXXSpecialNameExtra *castAsCXXSpecialNameExtra() const {
310	(0) . __assert_fail ("(getStoredNameKind() == StoredCXXConstructorName \|\| getStoredNameKind() == StoredCXXDestructorName \|\| getStoredNameKind() == StoredCXXConversionFunctionName) && \"DeclarationName does not store a CXXSpecialNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 313, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert((getStoredNameKind() == StoredCXXConstructorName \|\|
311	(0) . __assert_fail ("(getStoredNameKind() == StoredCXXConstructorName \|\| getStoredNameKind() == StoredCXXDestructorName \|\| getStoredNameKind() == StoredCXXConversionFunctionName) && \"DeclarationName does not store a CXXSpecialNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 313, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> getStoredNameKind() == StoredCXXDestructorName \|\|
312	(0) . __assert_fail ("(getStoredNameKind() == StoredCXXConstructorName \|\| getStoredNameKind() == StoredCXXDestructorName \|\| getStoredNameKind() == StoredCXXConversionFunctionName) && \"DeclarationName does not store a CXXSpecialNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 313, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> getStoredNameKind() == StoredCXXConversionFunctionName) &&
313	(0) . __assert_fail ("(getStoredNameKind() == StoredCXXConstructorName \|\| getStoredNameKind() == StoredCXXDestructorName \|\| getStoredNameKind() == StoredCXXConversionFunctionName) && \"DeclarationName does not store a CXXSpecialNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 313, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "DeclarationName does not store a CXXSpecialNameExtra!");
314	return static_cast<detail::CXXSpecialNameExtra *>(getPtr());
315	}
316
317	/// Assert that the stored pointer points to a CXXOperatorIdName
318	/// and return it.
319	detail::CXXOperatorIdName *castAsCXXOperatorIdName() const {
320	(0) . __assert_fail ("(getStoredNameKind() == StoredCXXOperatorName) && \"DeclarationName does not store a CXXOperatorIdName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 321, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert((getStoredNameKind() == StoredCXXOperatorName) &&
321	(0) . __assert_fail ("(getStoredNameKind() == StoredCXXOperatorName) && \"DeclarationName does not store a CXXOperatorIdName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 321, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "DeclarationName does not store a CXXOperatorIdName!");
322	return static_cast<detail::CXXOperatorIdName *>(getPtr());
323	}
324
325	/// Assert that the stored pointer points to a CXXDeductionGuideNameExtra
326	/// and return it.
327	detail::CXXDeductionGuideNameExtra *castAsCXXDeductionGuideNameExtra() const {
328	(0) . __assert_fail ("getNameKind() == CXXDeductionGuideName && \"DeclarationName does not store a CXXDeductionGuideNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 329, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(getNameKind() == CXXDeductionGuideName &&
329	(0) . __assert_fail ("getNameKind() == CXXDeductionGuideName && \"DeclarationName does not store a CXXDeductionGuideNameExtra!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 329, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "DeclarationName does not store a CXXDeductionGuideNameExtra!");
330	return static_cast<detail::CXXDeductionGuideNameExtra *>(getPtr());
331	}
332
333	/// Assert that the stored pointer points to a CXXLiteralOperatorIdName
334	/// and return it.
335	detail::CXXLiteralOperatorIdName *castAsCXXLiteralOperatorIdName() const {
336	(0) . __assert_fail ("getNameKind() == CXXLiteralOperatorName && \"DeclarationName does not store a CXXLiteralOperatorIdName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 337, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(getNameKind() == CXXLiteralOperatorName &&
337	(0) . __assert_fail ("getNameKind() == CXXLiteralOperatorName && \"DeclarationName does not store a CXXLiteralOperatorIdName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 337, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "DeclarationName does not store a CXXLiteralOperatorIdName!");
338	return static_cast<detail::CXXLiteralOperatorIdName *>(getPtr());
339	}
340
341	/// Get and set the FETokenInfo in the less common cases where the
342	/// declaration name do not point to an identifier.
343	void *getFETokenInfoSlow() const;
344	void setFETokenInfoSlow(void *T);
345
346	public:
347	/// Construct an empty declaration name.
348	DeclarationName() { setPtrAndKind(nullptr, StoredIdentifier); }
349
350	/// Construct a declaration name from an IdentifierInfo *.
351	DeclarationName(const IdentifierInfo *II) {
352	setPtrAndKind(II, StoredIdentifier);
353	}
354
355	/// Construct a declaration name from an Objective-C selector.
356	DeclarationName(Selector Sel) : Ptr(Sel.InfoPtr) {}
357
358	/// Returns the name for all C++ using-directives.
359	static DeclarationName getUsingDirectiveName() {
360	// Single instance of DeclarationNameExtra for using-directive
361	static detail::DeclarationNameExtra UDirExtra(
362	detail::DeclarationNameExtra::CXXUsingDirective);
363	return DeclarationName(&UDirExtra);
364	}
365
366	/// Evaluates true when this declaration name is non-empty.
367	explicit operator bool() const {
368	return getPtr() \|\| (getStoredNameKind() != StoredIdentifier);
369	}
370
371	/// Evaluates true when this declaration name is empty.
372	bool isEmpty() const { return !*this; }
373
374	/// Predicate functions for querying what type of name this is.
375	bool isIdentifier() const { return getStoredNameKind() == StoredIdentifier; }
376	bool isObjCZeroArgSelector() const {
377	return getStoredNameKind() == StoredObjCZeroArgSelector;
378	}
379	bool isObjCOneArgSelector() const {
380	return getStoredNameKind() == StoredObjCOneArgSelector;
381	}
382
383	/// Determine what kind of name this is.
384	NameKind getNameKind() const {
385	// We rely on the fact that the first 7 NameKind and StoredNameKind
386	// have the same numerical value. This makes the usual case efficient.
387	StoredNameKind StoredKind = getStoredNameKind();
388	if (StoredKind != StoredDeclarationNameExtra)
389	return static_cast<NameKind>(StoredKind);
390	// We have to consult DeclarationNameExtra. We rely on the fact that the
391	// enumeration values of ExtraKind correspond to the enumeration values of
392	// NameKind minus an offset of UncommonNameKindOffset.
393	unsigned ExtraKind = castAsExtra()->getKind();
394	return static_cast<NameKind>(UncommonNameKindOffset + ExtraKind);
395	}
396
397	/// Determines whether the name itself is dependent, e.g., because it
398	/// involves a C++ type that is itself dependent.
399	///
400	/// Note that this does not capture all of the notions of "dependent name",
401	/// because an identifier can be a dependent name if it is used as the
402	/// callee in a call expression with dependent arguments.
403	bool isDependentName() const;
404
405	/// Retrieve the human-readable string for this name.
406	std::string getAsString() const;
407
408	/// Retrieve the IdentifierInfo * stored in this declaration name,
409	/// or null if this declaration name isn't a simple identifier.
410	IdentifierInfo *getAsIdentifierInfo() const {
411	if (isIdentifier())
412	return castAsIdentifierInfo();
413	return nullptr;
414	}
415
416	/// Get the representation of this declaration name as an opaque integer.
417	uintptr_t getAsOpaqueInteger() const { return Ptr; }
418
419	/// Get the representation of this declaration name as an opaque pointer.
420	void getAsOpaquePtr() const { return reinterpret_cast<void >(Ptr); }
421
422	/// Get a declaration name from an opaque pointer returned by getAsOpaquePtr.
423	static DeclarationName getFromOpaquePtr(void *P) {
424	DeclarationName N;
425	N.Ptr = reinterpret_cast<uintptr_t>(P);
426	return N;
427	}
428
429	/// Get a declaration name from an opaque integer
430	/// returned by getAsOpaqueInteger.
431	static DeclarationName getFromOpaqueInteger(uintptr_t P) {
432	DeclarationName N;
433	N.Ptr = P;
434	return N;
435	}
436
437	/// If this name is one of the C++ names (of a constructor, destructor,
438	/// or conversion function), return the type associated with that name.
439	QualType getCXXNameType() const {
440	if (getStoredNameKind() == StoredCXXConstructorName \|\|
441	getStoredNameKind() == StoredCXXDestructorName \|\|
442	getStoredNameKind() == StoredCXXConversionFunctionName) {
443	(0) . __assert_fail ("getPtr() && \"getCXXNameType on a null DeclarationName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 443, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(getPtr() && "getCXXNameType on a null DeclarationName!");
444	return castAsCXXSpecialNameExtra()->Type;
445	}
446	return QualType();
447	}
448
449	/// If this name is the name of a C++ deduction guide, return the
450	/// template associated with that name.
451	TemplateDecl *getCXXDeductionGuideTemplate() const {
452	if (getNameKind() == CXXDeductionGuideName) {
453	(0) . __assert_fail ("getPtr() && \"getCXXDeductionGuideTemplate on a null DeclarationName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 454, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(getPtr() &&
454	(0) . __assert_fail ("getPtr() && \"getCXXDeductionGuideTemplate on a null DeclarationName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 454, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "getCXXDeductionGuideTemplate on a null DeclarationName!");
455	return castAsCXXDeductionGuideNameExtra()->Template;
456	}
457	return nullptr;
458	}
459
460	/// If this name is the name of an overloadable operator in C++
461	/// (e.g., @c operator+), retrieve the kind of overloaded operator.
462	OverloadedOperatorKind getCXXOverloadedOperator() const {
463	if (getStoredNameKind() == StoredCXXOperatorName) {
464	(0) . __assert_fail ("getPtr() && \"getCXXOverloadedOperator on a null DeclarationName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 464, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(getPtr() && "getCXXOverloadedOperator on a null DeclarationName!");
465	return castAsCXXOperatorIdName()->Kind;
466	}
467	return OO_None;
468	}
469
470	/// If this name is the name of a literal operator,
471	/// retrieve the identifier associated with it.
472	IdentifierInfo *getCXXLiteralIdentifier() const {
473	if (getNameKind() == CXXLiteralOperatorName) {
474	(0) . __assert_fail ("getPtr() && \"getCXXLiteralIdentifier on a null DeclarationName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 474, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(getPtr() && "getCXXLiteralIdentifier on a null DeclarationName!");
475	return castAsCXXLiteralOperatorIdName()->ID;
476	}
477	return nullptr;
478	}
479
480	/// Get the Objective-C selector stored in this declaration name.
481	Selector getObjCSelector() const {
482	(0) . __assert_fail ("(getNameKind() == ObjCZeroArgSelector \|\| getNameKind() == ObjCOneArgSelector \|\| getNameKind() == ObjCMultiArgSelector \|\| !getPtr()) && \"Not a selector!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 485, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert((getNameKind() == ObjCZeroArgSelector \|\|
483	(0) . __assert_fail ("(getNameKind() == ObjCZeroArgSelector \|\| getNameKind() == ObjCOneArgSelector \|\| getNameKind() == ObjCMultiArgSelector \|\| !getPtr()) && \"Not a selector!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 485, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> getNameKind() == ObjCOneArgSelector \|\|
484	(0) . __assert_fail ("(getNameKind() == ObjCZeroArgSelector \|\| getNameKind() == ObjCOneArgSelector \|\| getNameKind() == ObjCMultiArgSelector \|\| !getPtr()) && \"Not a selector!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 485, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> getNameKind() == ObjCMultiArgSelector \|\| !getPtr()) &&
485	(0) . __assert_fail ("(getNameKind() == ObjCZeroArgSelector \|\| getNameKind() == ObjCOneArgSelector \|\| getNameKind() == ObjCMultiArgSelector \|\| !getPtr()) && \"Not a selector!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 485, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "Not a selector!");
486	return Selector(Ptr);
487	}
488
489	/// Get and set FETokenInfo. The language front-end is allowed to associate
490	/// arbitrary metadata with some kinds of declaration names, including normal
491	/// identifiers and C++ constructors, destructors, and conversion functions.
492	void *getFETokenInfo() const {
493	(0) . __assert_fail ("getPtr() && \"getFETokenInfo on an empty DeclarationName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 493, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(getPtr() && "getFETokenInfo on an empty DeclarationName!");
494	if (getStoredNameKind() == StoredIdentifier)
495	return castAsIdentifierInfo()->getFETokenInfo();
496	return getFETokenInfoSlow();
497	}
498
499	void setFETokenInfo(void *T) {
500	(0) . __assert_fail ("getPtr() && \"setFETokenInfo on an empty DeclarationName!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclarationName.h", 500, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(getPtr() && "setFETokenInfo on an empty DeclarationName!");
501	if (getStoredNameKind() == StoredIdentifier)
502	castAsIdentifierInfo()->setFETokenInfo(T);
503	else
504	setFETokenInfoSlow(T);
505	}
506
507	/// Determine whether the specified names are identical.
508	friend bool operator==(DeclarationName LHS, DeclarationName RHS) {
509	return LHS.Ptr == RHS.Ptr;
510	}
511
512	/// Determine whether the specified names are different.
513	friend bool operator!=(DeclarationName LHS, DeclarationName RHS) {
514	return LHS.Ptr != RHS.Ptr;
515	}
516
517	static DeclarationName getEmptyMarker() {
518	DeclarationName Name;
519	Name.Ptr = uintptr_t(-1);
520	return Name;
521	}
522
523	static DeclarationName getTombstoneMarker() {
524	DeclarationName Name;
525	Name.Ptr = uintptr_t(-2);
526	return Name;
527	}
528
529	static int compare(DeclarationName LHS, DeclarationName RHS);
530
531	void print(raw_ostream &OS, const PrintingPolicy &Policy);
532
533	void dump() const;
534	};
535
536	raw_ostream &operator<<(raw_ostream &OS, DeclarationName N);
537
538	/// Ordering on two declaration names. If both names are identifiers,
539	/// this provides a lexicographical ordering.
540	inline bool operator<(DeclarationName LHS, DeclarationName RHS) {
541	return DeclarationName::compare(LHS, RHS) < 0;
542	}
543
544	/// Ordering on two declaration names. If both names are identifiers,
545	/// this provides a lexicographical ordering.
546	inline bool operator>(DeclarationName LHS, DeclarationName RHS) {
547	return DeclarationName::compare(LHS, RHS) > 0;
548	}
549
550	/// Ordering on two declaration names. If both names are identifiers,
551	/// this provides a lexicographical ordering.
552	inline bool operator<=(DeclarationName LHS, DeclarationName RHS) {
553	return DeclarationName::compare(LHS, RHS) <= 0;
554	}
555
556	/// Ordering on two declaration names. If both names are identifiers,
557	/// this provides a lexicographical ordering.
558	inline bool operator>=(DeclarationName LHS, DeclarationName RHS) {
559	return DeclarationName::compare(LHS, RHS) >= 0;
560	}
561
562	/// DeclarationNameTable is used to store and retrieve DeclarationName
563	/// instances for the various kinds of declaration names, e.g., normal
564	/// identifiers, C++ constructor names, etc. This class contains
565	/// uniqued versions of each of the C++ special names, which can be
566	/// retrieved using its member functions (e.g., getCXXConstructorName).
567	class DeclarationNameTable {
568	/// Used to allocate elements in the FoldingSets below.
569	const ASTContext &Ctx;
570
571	/// Manage the uniqued CXXSpecialNameExtra representing C++ constructors.
572	/// getCXXConstructorName and getCXXSpecialName can be used to obtain
573	/// a DeclarationName from the corresponding type of the constructor.
574	llvm::FoldingSet<detail::CXXSpecialNameExtra> CXXConstructorNames;
575
576	/// Manage the uniqued CXXSpecialNameExtra representing C++ destructors.
577	/// getCXXDestructorName and getCXXSpecialName can be used to obtain
578	/// a DeclarationName from the corresponding type of the destructor.
579	llvm::FoldingSet<detail::CXXSpecialNameExtra> CXXDestructorNames;
580
581	/// Manage the uniqued CXXSpecialNameExtra representing C++ conversion
582	/// functions. getCXXConversionFunctionName and getCXXSpecialName can be
583	/// used to obtain a DeclarationName from the corresponding type of the
584	/// conversion function.
585	llvm::FoldingSet<detail::CXXSpecialNameExtra> CXXConversionFunctionNames;
586
587	/// Manage the uniqued CXXOperatorIdName, which contain extra information
588	/// for the name of overloaded C++ operators. getCXXOperatorName
589	/// can be used to obtain a DeclarationName from the operator kind.
590	detail::CXXOperatorIdName CXXOperatorNames[NUM_OVERLOADED_OPERATORS];
591
592	/// Manage the uniqued CXXLiteralOperatorIdName, which contain extra
593	/// information for the name of C++ literal operators.
594	/// getCXXLiteralOperatorName can be used to obtain a DeclarationName
595	/// from the corresponding IdentifierInfo.
596	llvm::FoldingSet<detail::CXXLiteralOperatorIdName> CXXLiteralOperatorNames;
597
598	/// Manage the uniqued CXXDeductionGuideNameExtra, which contain
599	/// extra information for the name of a C++ deduction guide.
600	/// getCXXDeductionGuideName can be used to obtain a DeclarationName
601	/// from the corresponding template declaration.
602	llvm::FoldingSet<detail::CXXDeductionGuideNameExtra> CXXDeductionGuideNames;
603
604	public:
605	DeclarationNameTable(const ASTContext &C);
606	DeclarationNameTable(const DeclarationNameTable &) = delete;
607	DeclarationNameTable &operator=(const DeclarationNameTable &) = delete;
608	DeclarationNameTable(DeclarationNameTable &&) = delete;
609	DeclarationNameTable &operator=(DeclarationNameTable &&) = delete;
610	~DeclarationNameTable() = default;
611
612	/// Create a declaration name that is a simple identifier.
613	DeclarationName getIdentifier(const IdentifierInfo *ID) {
614	return DeclarationName(ID);
615	}
616
617	/// Returns the name of a C++ constructor for the given Type.
618	DeclarationName getCXXConstructorName(CanQualType Ty);
619
620	/// Returns the name of a C++ destructor for the given Type.
621	DeclarationName getCXXDestructorName(CanQualType Ty);
622
623	/// Returns the name of a C++ deduction guide for the given template.
624	DeclarationName getCXXDeductionGuideName(TemplateDecl *TD);
625
626	/// Returns the name of a C++ conversion function for the given Type.
627	DeclarationName getCXXConversionFunctionName(CanQualType Ty);
628
629	/// Returns a declaration name for special kind of C++ name,
630	/// e.g., for a constructor, destructor, or conversion function.
631	/// Kind must be one of:
632	/// * DeclarationName::CXXConstructorName,
633	/// * DeclarationName::CXXDestructorName or
634	/// * DeclarationName::CXXConversionFunctionName
635	DeclarationName getCXXSpecialName(DeclarationName::NameKind Kind,
636	CanQualType Ty);
637
638	/// Get the name of the overloadable C++ operator corresponding to Op.
639	DeclarationName getCXXOperatorName(OverloadedOperatorKind Op) {
640	return DeclarationName(&CXXOperatorNames[Op]);
641	}
642
643	/// Get the name of the literal operator function with II as the identifier.
644	DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II);
645	};
646
647	/// DeclarationNameLoc - Additional source/type location info
648	/// for a declaration name. Needs a DeclarationName in order
649	/// to be interpreted correctly.
650	struct DeclarationNameLoc {
651	// The source location for identifier stored elsewhere.
652	// struct {} Identifier;
653
654	// Type info for constructors, destructors and conversion functions.
655	// Locations (if any) for the tilde (destructor) or operator keyword
656	// (conversion) are stored elsewhere.
657	struct NT {
658	TypeSourceInfo *TInfo;
659	};
660
661	// The location (if any) of the operator keyword is stored elsewhere.
662	struct CXXOpName {
663	unsigned BeginOpNameLoc;
664	unsigned EndOpNameLoc;
665	};
666
667	// The location (if any) of the operator keyword is stored elsewhere.
668	struct CXXLitOpName {
669	unsigned OpNameLoc;
670	};
671
672	// struct {} CXXUsingDirective;
673	// struct {} ObjCZeroArgSelector;
674	// struct {} ObjCOneArgSelector;
675	// struct {} ObjCMultiArgSelector;
676	union {
677	struct NT NamedType;
678	struct CXXOpName CXXOperatorName;
679	struct CXXLitOpName CXXLiteralOperatorName;
680	};
681
682	DeclarationNameLoc(DeclarationName Name);
683
684	// FIXME: this should go away once all DNLocs are properly initialized.
685	DeclarationNameLoc() { memset((void) this, 0, sizeof(this)); }
686	};
687
688	/// DeclarationNameInfo - A collector data type for bundling together
689	/// a DeclarationName and the correspnding source/type location info.
690	struct DeclarationNameInfo {
691	private:
692	/// Name - The declaration name, also encoding name kind.
693	DeclarationName Name;
694
695	/// Loc - The main source location for the declaration name.
696	SourceLocation NameLoc;
697
698	/// Info - Further source/type location info for special kinds of names.
699	DeclarationNameLoc LocInfo;
700
701	public:
702	// FIXME: remove it.
703	DeclarationNameInfo() = default;
704
705	DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc)
706	: Name(Name), NameLoc(NameLoc), LocInfo(Name) {}
707
708	DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc,
709	DeclarationNameLoc LocInfo)
710	: Name(Name), NameLoc(NameLoc), LocInfo(LocInfo) {}
711
712	/// getName - Returns the embedded declaration name.
713	DeclarationName getName() const { return Name; }
714
715	/// setName - Sets the embedded declaration name.
716	void setName(DeclarationName N) { Name = N; }
717
718	/// getLoc - Returns the main location of the declaration name.
719	SourceLocation getLoc() const { return NameLoc; }
720
721	/// setLoc - Sets the main location of the declaration name.
722	void setLoc(SourceLocation L) { NameLoc = L; }
723
724	const DeclarationNameLoc &getInfo() const { return LocInfo; }
725	DeclarationNameLoc &getInfo() { return LocInfo; }
726	void setInfo(const DeclarationNameLoc &Info) { LocInfo = Info; }
727
728	/// getNamedTypeInfo - Returns the source type info associated to
729	/// the name. Assumes it is a constructor, destructor or conversion.
730	TypeSourceInfo *getNamedTypeInfo() const {
731	if (Name.getNameKind() != DeclarationName::CXXConstructorName &&
732	Name.getNameKind() != DeclarationName::CXXDestructorName &&
733	Name.getNameKind() != DeclarationName::CXXConversionFunctionName)
734	return nullptr;
735	return LocInfo.NamedType.TInfo;
736	}
737
738	/// setNamedTypeInfo - Sets the source type info associated to
739	/// the name. Assumes it is a constructor, destructor or conversion.
740	void setNamedTypeInfo(TypeSourceInfo *TInfo) {
741	assert(Name.getNameKind() == DeclarationName::CXXConstructorName \|\|
742	Name.getNameKind() == DeclarationName::CXXDestructorName \|\|
743	Name.getNameKind() == DeclarationName::CXXConversionFunctionName);
744	LocInfo.NamedType.TInfo = TInfo;
745	}
746
747	/// getCXXOperatorNameRange - Gets the range of the operator name
748	/// (without the operator keyword). Assumes it is a (non-literal) operator.
749	SourceRange getCXXOperatorNameRange() const {
750	if (Name.getNameKind() != DeclarationName::CXXOperatorName)
751	return SourceRange();
752	return SourceRange(
753	SourceLocation::getFromRawEncoding(LocInfo.CXXOperatorName.BeginOpNameLoc),
754	SourceLocation::getFromRawEncoding(LocInfo.CXXOperatorName.EndOpNameLoc)
755	);
756	}
757
758	/// setCXXOperatorNameRange - Sets the range of the operator name
759	/// (without the operator keyword). Assumes it is a C++ operator.
760	void setCXXOperatorNameRange(SourceRange R) {
761	assert(Name.getNameKind() == DeclarationName::CXXOperatorName);
762	LocInfo.CXXOperatorName.BeginOpNameLoc = R.getBegin().getRawEncoding();
763	LocInfo.CXXOperatorName.EndOpNameLoc = R.getEnd().getRawEncoding();
764	}
765
766	/// getCXXLiteralOperatorNameLoc - Returns the location of the literal
767	/// operator name (not the operator keyword).
768	/// Assumes it is a literal operator.
769	SourceLocation getCXXLiteralOperatorNameLoc() const {
770	if (Name.getNameKind() != DeclarationName::CXXLiteralOperatorName)
771	return SourceLocation();
772	return SourceLocation::
773	getFromRawEncoding(LocInfo.CXXLiteralOperatorName.OpNameLoc);
774	}
775
776	/// setCXXLiteralOperatorNameLoc - Sets the location of the literal
777	/// operator name (not the operator keyword).
778	/// Assumes it is a literal operator.
779	void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {
780	assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);
781	LocInfo.CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding();
782	}
783
784	/// Determine whether this name involves a template parameter.
785	bool isInstantiationDependent() const;
786
787	/// Determine whether this name contains an unexpanded
788	/// parameter pack.
789	bool containsUnexpandedParameterPack() const;
790
791	/// getAsString - Retrieve the human-readable string for this name.
792	std::string getAsString() const;
793
794	/// printName - Print the human-readable name to a stream.
795	void printName(raw_ostream &OS) const;
796
797	/// getBeginLoc - Retrieve the location of the first token.
798	SourceLocation getBeginLoc() const { return NameLoc; }
799
800	/// getSourceRange - The range of the declaration name.
801	SourceRange getSourceRange() const LLVM_READONLY {
802	return SourceRange(getBeginLoc(), getEndLoc());
803	}
804
805	SourceLocation getEndLoc() const LLVM_READONLY {
806	SourceLocation EndLoc = getEndLocPrivate();
807	return EndLoc.isValid() ? EndLoc : getBeginLoc();
808	}
809
810	private:
811	SourceLocation getEndLocPrivate() const;
812	};
813
814	/// Insertion operator for diagnostics. This allows sending DeclarationName's
815	/// into a diagnostic with <<.
816	inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
817	DeclarationName N) {
818	DB.AddTaggedVal(N.getAsOpaqueInteger(),
819	DiagnosticsEngine::ak_declarationname);
820	return DB;
821	}
822
823	/// Insertion operator for partial diagnostics. This allows binding
824	/// DeclarationName's into a partial diagnostic with <<.
825	inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
826	DeclarationName N) {
827	PD.AddTaggedVal(N.getAsOpaqueInteger(),
828	DiagnosticsEngine::ak_declarationname);
829	return PD;
830	}
831
832	inline raw_ostream &operator<<(raw_ostream &OS,
833	DeclarationNameInfo DNInfo) {
834	DNInfo.printName(OS);
835	return OS;
836	}
837
838	} // namespace clang
839
840	namespace llvm {
841
842	/// Define DenseMapInfo so that DeclarationNames can be used as keys
843	/// in DenseMap and DenseSets.
844	template<>
845	struct DenseMapInfo<clang::DeclarationName> {
846	static inline clang::DeclarationName getEmptyKey() {
847	return clang::DeclarationName::getEmptyMarker();
848	}
849
850	static inline clang::DeclarationName getTombstoneKey() {
851	return clang::DeclarationName::getTombstoneMarker();
852	}
853
854	static unsigned getHashValue(clang::DeclarationName Name) {
855	return DenseMapInfo<void*>::getHashValue(Name.getAsOpaquePtr());
856	}
857
858	static inline bool
859	isEqual(clang::DeclarationName LHS, clang::DeclarationName RHS) {
860	return LHS == RHS;
861	}
862	};
863
864	} // namespace llvm
865
866	#endif // LLVM_CLANG_AST_DECLARATIONNAME_H
867