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