Coverage Report

Created: 2022-05-14 11:35

/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
1.96M
  CXXSpecialNameExtra(QualType QT) : Type(QT), FETokenInfo(nullptr) {}
66
67
public:
68
14.5M
  void Profile(llvm::FoldingSetNodeID &ID) {
69
14.5M
    ID.AddPointer(Type.getAsOpaquePtr());
70
14.5M
  }
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
409
        FETokenInfo(nullptr) {}
91
92
public:
93
3.60k
  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
463
        FETokenInfo(nullptr) {}
131
132
public:
133
2.35k
  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.12G
  StoredNameKind getStoredNameKind() const {
266
4.12G
    return static_cast<StoredNameKind>(Ptr & PtrMask);
267
4.12G
  }
268
269
2.58G
  void *getPtr() const { return reinterpret_cast<void *>(Ptr & ~PtrMask); }
270
271
1.39G
  void setPtrAndKind(const void *P, StoredNameKind Kind) {
272
1.39G
    uintptr_t PAsInteger = reinterpret_cast<uintptr_t>(P);
273
1.39G
    assert((Kind & ~PtrMask) == 0 &&
274
1.39G
           "Invalid StoredNameKind in setPtrAndKind!");
275
0
    assert((PAsInteger & PtrMask) == 0 &&
276
1.39G
           "Improperly aligned pointer in setPtrAndKind!");
277
0
    Ptr = PAsInteger | Kind;
278
1.39G
  }
279
280
  /// Construct a declaration name from a DeclarationNameExtra.
281
88.8M
  DeclarationName(detail::DeclarationNameExtra *Name) {
282
88.8M
    setPtrAndKind(Name, StoredDeclarationNameExtra);
283
88.8M
  }
284
285
  /// Construct a declaration name from a CXXSpecialNameExtra.
286
  DeclarationName(detail::CXXSpecialNameExtra *Name,
287
10.4M
                  StoredNameKind StoredKind) {
288
10.4M
    assert((StoredKind == StoredCXXConstructorName ||
289
10.4M
           StoredKind == StoredCXXDestructorName ||
290
10.4M
           StoredKind == StoredCXXConversionFunctionName) &&
291
10.4M
               "Invalid StoredNameKind when constructing a DeclarationName"
292
10.4M
               " from a CXXSpecialNameExtra!");
293
0
    setPtrAndKind(Name, StoredKind);
294
10.4M
  }
295
296
  /// Construct a DeclarationName from a CXXOperatorIdName.
297
6.24M
  DeclarationName(detail::CXXOperatorIdName *Name) {
298
6.24M
    setPtrAndKind(Name, StoredCXXOperatorName);
299
6.24M
  }
300
301
  /// Assert that the stored pointer points to an IdentifierInfo and return it.
302
1.43G
  IdentifierInfo *castAsIdentifierInfo() const {
303
1.43G
    assert((getStoredNameKind() == StoredIdentifier) &&
304
1.43G
           "DeclarationName does not store an IdentifierInfo!");
305
0
    return static_cast<IdentifierInfo *>(getPtr());
306
1.43G
  }
307
308
  /// Assert that the stored pointer points to a DeclarationNameExtra
309
  /// and return it.
310
7.83M
  detail::DeclarationNameExtra *castAsExtra() const {
311
7.83M
    assert((getStoredNameKind() == StoredDeclarationNameExtra) &&
312
7.83M
           "DeclarationName does not store an Extra structure!");
313
0
    return static_cast<detail::DeclarationNameExtra *>(getPtr());
314
7.83M
  }
315
316
  /// Assert that the stored pointer points to a CXXSpecialNameExtra
317
  /// and return it.
318
5.12M
  detail::CXXSpecialNameExtra *castAsCXXSpecialNameExtra() const {
319
5.12M
    assert((getStoredNameKind() == StoredCXXConstructorName ||
320
5.12M
           getStoredNameKind() == StoredCXXDestructorName ||
321
5.12M
           getStoredNameKind() == StoredCXXConversionFunctionName) &&
322
5.12M
               "DeclarationName does not store a CXXSpecialNameExtra!");
323
0
    return static_cast<detail::CXXSpecialNameExtra *>(getPtr());
324
5.12M
  }
325
326
  /// Assert that the stored pointer points to a CXXOperatorIdName
327
  /// and return it.
328
37.4M
  detail::CXXOperatorIdName *castAsCXXOperatorIdName() const {
329
37.4M
    assert((getStoredNameKind() == StoredCXXOperatorName) &&
330
37.4M
           "DeclarationName does not store a CXXOperatorIdName!");
331
0
    return static_cast<detail::CXXOperatorIdName *>(getPtr());
332
37.4M
  }
333
334
  /// Assert that the stored pointer points to a CXXDeductionGuideNameExtra
335
  /// and return it.
336
17.0k
  detail::CXXDeductionGuideNameExtra *castAsCXXDeductionGuideNameExtra() const {
337
17.0k
    assert(getNameKind() == CXXDeductionGuideName &&
338
17.0k
           "DeclarationName does not store a CXXDeductionGuideNameExtra!");
339
0
    return static_cast<detail::CXXDeductionGuideNameExtra *>(getPtr());
340
17.0k
  }
341
342
  /// Assert that the stored pointer points to a CXXLiteralOperatorIdName
343
  /// and return it.
344
10.3k
  detail::CXXLiteralOperatorIdName *castAsCXXLiteralOperatorIdName() const {
345
10.3k
    assert(getNameKind() == CXXLiteralOperatorName &&
346
10.3k
           "DeclarationName does not store a CXXLiteralOperatorIdName!");
347
0
    return static_cast<detail::CXXLiteralOperatorIdName *>(getPtr());
348
10.3k
  }
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
838M
  DeclarationName() { setPtrAndKind(nullptr, StoredIdentifier); }
358
359
  /// Construct a declaration name from an IdentifierInfo *.
360
449M
  DeclarationName(const IdentifierInfo *II) {
361
449M
    setPtrAndKind(II, StoredIdentifier);
362
449M
  }
363
364
  /// Construct a declaration name from an Objective-C selector.
365
13.7M
  DeclarationName(Selector Sel) : Ptr(Sel.InfoPtr) {}
366
367
  /// Returns the name for all C++ using-directives.
368
88.8M
  static DeclarationName getUsingDirectiveName() {
369
    // Single instance of DeclarationNameExtra for using-directive
370
88.8M
    static detail::DeclarationNameExtra UDirExtra(
371
88.8M
        detail::DeclarationNameExtra::CXXUsingDirective);
372
88.8M
    return DeclarationName(&UDirExtra);
373
88.8M
  }
374
375
  /// Evaluates true when this declaration name is non-empty.
376
527M
  explicit operator bool() const {
377
527M
    return getPtr() || 
(getStoredNameKind() != StoredIdentifier)111M
;
378
527M
  }
379
380
  /// Evaluates true when this declaration name is empty.
381
5.83M
  bool isEmpty() const { return !*this; }
382
383
  /// Predicate functions for querying what type of name this is.
384
910M
  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
775M
  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
775M
    StoredNameKind StoredKind = getStoredNameKind();
397
775M
    if (StoredKind != StoredDeclarationNameExtra)
398
767M
      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.83M
    unsigned ExtraKind = castAsExtra()->getKind();
403
7.83M
    return static_cast<NameKind>(UncommonNameKindOffset + ExtraKind);
404
775M
  }
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
897M
  IdentifierInfo *getAsIdentifierInfo() const {
420
897M
    if (isIdentifier())
421
881M
      return castAsIdentifierInfo();
422
16.4M
    return nullptr;
423
897M
  }
424
425
  /// Get the representation of this declaration name as an opaque integer.
426
139k
  uintptr_t getAsOpaqueInteger() const { return Ptr; }
427
428
  /// Get the representation of this declaration name as an opaque pointer.
429
279M
  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
24.9k
  static DeclarationName getFromOpaqueInteger(uintptr_t P) {
441
24.9k
    DeclarationName N;
442
24.9k
    N.Ptr = P;
443
24.9k
    return N;
444
24.9k
  }
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.47M
  QualType getCXXNameType() const {
449
2.47M
    if (getStoredNameKind() == StoredCXXConstructorName ||
450
2.47M
        
getStoredNameKind() == StoredCXXDestructorName1.06M
||
451
2.47M
        
getStoredNameKind() == StoredCXXConversionFunctionName988k
) {
452
2.07M
      assert(getPtr() && "getCXXNameType on a null DeclarationName!");
453
0
      return castAsCXXSpecialNameExtra()->Type;
454
2.07M
    }
455
402k
    return QualType();
456
2.47M
  }
457
458
  /// If this name is the name of a C++ deduction guide, return the
459
  /// template associated with that name.
460
415k
  TemplateDecl *getCXXDeductionGuideTemplate() const {
461
415k
    if (getNameKind() == CXXDeductionGuideName) {
462
12.1k
      assert(getPtr() &&
463
12.1k
             "getCXXDeductionGuideTemplate on a null DeclarationName!");
464
0
      return castAsCXXDeductionGuideNameExtra()->Template;
465
12.1k
    }
466
403k
    return nullptr;
467
415k
  }
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
300M
  OverloadedOperatorKind getCXXOverloadedOperator() const {
472
300M
    if (getStoredNameKind() == StoredCXXOperatorName) {
473
33.2M
      assert(getPtr() && "getCXXOverloadedOperator on a null DeclarationName!");
474
0
      return castAsCXXOperatorIdName()->Kind;
475
33.2M
    }
476
266M
    return OO_None;
477
300M
  }
478
479
  /// If this name is the name of a literal operator,
480
  /// retrieve the identifier associated with it.
481
4.37k
  IdentifierInfo *getCXXLiteralIdentifier() const {
482
4.37k
    if (getNameKind() == CXXLiteralOperatorName) {
483
4.37k
      assert(getPtr() && "getCXXLiteralIdentifier on a null DeclarationName!");
484
0
      return castAsCXXLiteralOperatorIdName()->ID;
485
4.37k
    }
486
0
    return nullptr;
487
4.37k
  }
488
489
  /// Get the Objective-C selector stored in this declaration name.
490
17.5M
  Selector getObjCSelector() const {
491
17.5M
    assert((getNameKind() == ObjCZeroArgSelector ||
492
17.5M
            getNameKind() == ObjCOneArgSelector ||
493
17.5M
            getNameKind() == ObjCMultiArgSelector || !getPtr()) &&
494
17.5M
           "Not a selector!");
495
0
    return Selector(Ptr);
496
17.5M
  }
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
458M
  void *getFETokenInfo() const {
502
458M
    assert(getPtr() && "getFETokenInfo on an empty DeclarationName!");
503
458M
    if (getStoredNameKind() == StoredIdentifier)
504
451M
      return castAsIdentifierInfo()->getFETokenInfo();
505
6.64M
    return getFETokenInfoSlow();
506
458M
  }
507
508
78.6M
  void setFETokenInfo(void *T) {
509
78.6M
    assert(getPtr() && "setFETokenInfo on an empty DeclarationName!");
510
78.6M
    if (getStoredNameKind() == StoredIdentifier)
511
78.0M
      castAsIdentifierInfo()->setFETokenInfo(T);
512
551k
    else
513
551k
      setFETokenInfoSlow(T);
514
78.6M
  }
515
516
  /// Determine whether the specified names are identical.
517
3.58G
  friend bool operator==(DeclarationName LHS, DeclarationName RHS) {
518
3.58G
    return LHS.Ptr == RHS.Ptr;
519
3.58G
  }
520
521
  /// Determine whether the specified names are different.
522
11.2M
  friend bool operator!=(DeclarationName LHS, DeclarationName RHS) {
523
11.2M
    return LHS.Ptr != RHS.Ptr;
524
11.2M
  }
525
526
308M
  static DeclarationName getEmptyMarker() {
527
308M
    DeclarationName Name;
528
308M
    Name.Ptr = uintptr_t(-1);
529
308M
    return Name;
530
308M
  }
531
532
281M
  static DeclarationName getTombstoneMarker() {
533
281M
    DeclarationName Name;
534
281M
    Name.Ptr = uintptr_t(-2);
535
281M
    return Name;
536
281M
  }
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.4M
inline bool operator<(DeclarationName LHS, DeclarationName RHS) {
550
10.4M
  return DeclarationName::compare(LHS, RHS) < 0;
551
10.4M
}
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
90.1k
  ~DeclarationNameTable() = default;
620
621
  /// Create a declaration name that is a simple identifier.
622
75.1k
  DeclarationName getIdentifier(const IdentifierInfo *ID) {
623
75.1k
    return DeclarationName(ID);
624
75.1k
  }
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
6.24M
  DeclarationName getCXXOperatorName(OverloadedOperatorKind Op) {
649
6.24M
    return DeclarationName(&CXXOperatorNames[Op]);
650
6.24M
  }
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
2.88M
  void setNamedTypeLoc(TypeSourceInfo *TInfo) { NamedType.TInfo = TInfo; }
692
693
6.43M
  void setCXXOperatorNameRange(SourceRange Range) {
694
6.43M
    CXXOperatorName.BeginOpNameLoc = Range.getBegin().getRawEncoding();
695
6.43M
    CXXOperatorName.EndOpNameLoc = Range.getEnd().getRawEncoding();
696
6.43M
  }
697
698
3.58k
  void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {
699
3.58k
    CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding();
700
3.58k
  }
701
702
public:
703
  DeclarationNameLoc(DeclarationName Name);
704
  // FIXME: this should go away once all DNLocs are properly initialized.
705
132M
  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.24M
  TypeSourceInfo *getNamedTypeInfo() const { return NamedType.TInfo; }
710
711
  /// Return the beginning location of the getCXXOperatorNameRange() range.
712
711k
  SourceLocation getCXXOperatorNameBeginLoc() const {
713
711k
    return SourceLocation::getFromRawEncoding(CXXOperatorName.BeginOpNameLoc);
714
711k
  }
715
716
  /// Return the end location of the getCXXOperatorNameRange() range.
717
1.56M
  SourceLocation getCXXOperatorNameEndLoc() const {
718
1.56M
    return SourceLocation::getFromRawEncoding(CXXOperatorName.EndOpNameLoc);
719
1.56M
  }
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
650k
  SourceRange getCXXOperatorNameRange() const {
725
650k
    return SourceRange(getCXXOperatorNameBeginLoc(),
726
650k
                       getCXXOperatorNameEndLoc());
727
650k
  }
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.60k
  SourceLocation getCXXLiteralOperatorNameLoc() const {
733
1.60k
    return SourceLocation::getFromRawEncoding(CXXLiteralOperatorName.OpNameLoc);
734
1.60k
  }
735
736
  /// Construct location information for a constructor, destructor or conversion
737
  /// operator.
738
1.94M
  static DeclarationNameLoc makeNamedTypeLoc(TypeSourceInfo *TInfo) {
739
1.94M
    DeclarationNameLoc DNL;
740
1.94M
    DNL.setNamedTypeLoc(TInfo);
741
1.94M
    return DNL;
742
1.94M
  }
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.43M
  static DeclarationNameLoc makeCXXOperatorNameLoc(SourceRange Range) {
752
2.43M
    DeclarationNameLoc DNL;
753
2.43M
    DNL.setCXXOperatorNameRange(Range);
754
2.43M
    return DNL;
755
2.43M
  }
756
757
  /// Construct location information for a literal C++ operator.
758
2.77k
  static DeclarationNameLoc makeCXXLiteralOperatorNameLoc(SourceLocation Loc) {
759
2.77k
    DeclarationNameLoc DNL;
760
2.77k
    DNL.setCXXLiteralOperatorNameLoc(Loc);
761
2.77k
    return DNL;
762
2.77k
  }
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
119M
  DeclarationNameInfo() = default;
781
782
  DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc)
783
161M
      : Name(Name), NameLoc(NameLoc), LocInfo(Name) {}
784
785
  DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc,
786
                      DeclarationNameLoc LocInfo)
787
133M
      : Name(Name), NameLoc(NameLoc), LocInfo(LocInfo) {}
788
789
  /// getName - Returns the embedded declaration name.
790
1.11G
  DeclarationName getName() const { return Name; }
791
792
  /// setName - Sets the embedded declaration name.
793
100M
  void setName(DeclarationName N) { Name = N; }
794
795
  /// getLoc - Returns the main location of the declaration name.
796
197M
  SourceLocation getLoc() const { return NameLoc; }
797
798
  /// setLoc - Sets the main location of the declaration name.
799
99.9M
  void setLoc(SourceLocation L) { NameLoc = L; }
800
801
53.3M
  const DeclarationNameLoc &getInfo() const { return LocInfo; }
802
1.93M
  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
916k
  TypeSourceInfo *getNamedTypeInfo() const {
807
916k
    if (Name.getNameKind() != DeclarationName::CXXConstructorName &&
808
916k
        
Name.getNameKind() != DeclarationName::CXXDestructorName123k
&&
809
916k
        
Name.getNameKind() != DeclarationName::CXXConversionFunctionName33.0k
)
810
0
      return nullptr;
811
916k
    return LocInfo.getNamedTypeInfo();
812
916k
  }
813
814
  /// setNamedTypeInfo - Sets the source type info associated to
815
  /// the name. Assumes it is a constructor, destructor or conversion.
816
1.71M
  void setNamedTypeInfo(TypeSourceInfo *TInfo) {
817
1.71M
    assert(Name.getNameKind() == DeclarationName::CXXConstructorName ||
818
1.71M
           Name.getNameKind() == DeclarationName::CXXDestructorName ||
819
1.71M
           Name.getNameKind() == DeclarationName::CXXConversionFunctionName);
820
0
    LocInfo = DeclarationNameLoc::makeNamedTypeLoc(TInfo);
821
1.71M
  }
822
823
  /// getCXXOperatorNameRange - Gets the range of the operator name
824
  /// (without the operator keyword). Assumes it is a (non-literal) operator.
825
526k
  SourceRange getCXXOperatorNameRange() const {
826
526k
    if (Name.getNameKind() != DeclarationName::CXXOperatorName)
827
0
      return SourceRange();
828
526k
    return LocInfo.getCXXOperatorNameRange();
829
526k
  }
830
831
  /// setCXXOperatorNameRange - Sets the range of the operator name
832
  /// (without the operator keyword). Assumes it is a C++ operator.
833
1.71M
  void setCXXOperatorNameRange(SourceRange R) {
834
1.71M
    assert(Name.getNameKind() == DeclarationName::CXXOperatorName);
835
0
    LocInfo = DeclarationNameLoc::makeCXXOperatorNameLoc(R);
836
1.71M
  }
837
838
  /// getCXXLiteralOperatorNameLoc - Returns the location of the literal
839
  /// operator name (not the operator keyword).
840
  /// Assumes it is a literal operator.
841
294
  SourceLocation getCXXLiteralOperatorNameLoc() const {
842
294
    if (Name.getNameKind() != DeclarationName::CXXLiteralOperatorName)
843
0
      return SourceLocation();
844
294
    return LocInfo.getCXXLiteralOperatorNameLoc();
845
294
  }
846
847
  /// setCXXLiteralOperatorNameLoc - Sets the location of the literal
848
  /// operator name (not the operator keyword).
849
  /// Assumes it is a literal operator.
850
2.77k
  void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {
851
2.77k
    assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);
852
0
    LocInfo = DeclarationNameLoc::makeCXXLiteralOperatorNameLoc(Loc);
853
2.77k
  }
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
118M
  SourceLocation getBeginLoc() const { return NameLoc; }
870
871
  /// getSourceRange - The range of the declaration name.
872
53.8k
  SourceRange getSourceRange() const LLVM_READONLY {
873
53.8k
    return SourceRange(getBeginLoc(), getEndLoc());
874
53.8k
  }
875
876
42.1M
  SourceLocation getEndLoc() const LLVM_READONLY {
877
42.1M
    SourceLocation EndLoc = getEndLocPrivate();
878
42.1M
    return EndLoc.isValid() ? 
EndLoc40.2M
:
getBeginLoc()1.86M
;
879
42.1M
  }
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
138k
                                             DeclarationName N) {
889
138k
  PD.AddTaggedVal(N.getAsOpaqueInteger(),
890
138k
                  DiagnosticsEngine::ak_declarationname);
891
138k
  return PD;
892
138k
}
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
308M
  static inline clang::DeclarationName getEmptyKey() {
905
308M
    return clang::DeclarationName::getEmptyMarker();
906
308M
  }
907
908
281M
  static inline clang::DeclarationName getTombstoneKey() {
909
281M
    return clang::DeclarationName::getTombstoneMarker();
910
281M
  }
911
912
274M
  static unsigned getHashValue(clang::DeclarationName Name) {
913
274M
    return DenseMapInfo<void*>::getHashValue(Name.getAsOpaquePtr());
914
274M
  }
915
916
  static inline bool
917
3.28G
  isEqual(clang::DeclarationName LHS, clang::DeclarationName RHS) {
918
3.28G
    return LHS == RHS;
919
3.28G
  }
920
};
921
922
template <> struct PointerLikeTypeTraits<clang::DeclarationName> {
923
104k
  static inline void *getAsVoidPointer(clang::DeclarationName P) {
924
104k
    return P.getAsOpaquePtr();
925
104k
  }
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
835
      : UncommonTemplateNameStorage(Assumed, 0), Name(Name) {}
945
  DeclarationName Name;
946
947
public:
948
  /// Get the name of the template.
949
313
  DeclarationName getDeclName() const { return Name; }
950
};
951
952
} // namespace clang
953
954
#endif // LLVM_CLANG_AST_DECLARATIONNAME_H