Coverage Report

Created: 2021-09-21 08:58

/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/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
1.83M
  CXXSpecialNameExtra(QualType QT) : Type(QT), FETokenInfo(nullptr) {}
67
68
public:
69
14.0M
  void Profile(llvm::FoldingSetNodeID &ID) {
70
14.0M
    ID.AddPointer(Type.getAsOpaquePtr());
71
14.0M
  }
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
340
        FETokenInfo(nullptr) {}
92
93
public:
94
2.94k
  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
447
        FETokenInfo(nullptr) {}
132
133
public:
134
2.29k
  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
6.13G
  StoredNameKind getStoredNameKind() const {
257
6.13G
    return static_cast<StoredNameKind>(Ptr & PtrMask);
258
6.13G
  }
259
260
4.19G
  void *getPtr() const { return reinterpret_cast<void *>(Ptr & ~PtrMask); }
261
262
1.56G
  void setPtrAndKind(const void *P, StoredNameKind Kind) {
263
1.56G
    uintptr_t PAsInteger = reinterpret_cast<uintptr_t>(P);
264
1.56G
    assert((Kind & ~PtrMask) == 0 &&
265
1.56G
           "Invalid StoredNameKind in setPtrAndKind!");
266
0
    assert((PAsInteger & PtrMask) == 0 &&
267
1.56G
           "Improperly aligned pointer in setPtrAndKind!");
268
0
    Ptr = PAsInteger | Kind;
269
1.56G
  }
270
271
  /// Construct a declaration name from a DeclarationNameExtra.
272
93.5M
  DeclarationName(detail::DeclarationNameExtra *Name) {
273
93.5M
    setPtrAndKind(Name, StoredDeclarationNameExtra);
274
93.5M
  }
275
276
  /// Construct a declaration name from a CXXSpecialNameExtra.
277
  DeclarationName(detail::CXXSpecialNameExtra *Name,
278
10.0M
                  StoredNameKind StoredKind) {
279
10.0M
    assert((StoredKind == StoredCXXConstructorName ||
280
10.0M
           StoredKind == StoredCXXDestructorName ||
281
10.0M
           StoredKind == StoredCXXConversionFunctionName) &&
282
10.0M
               "Invalid StoredNameKind when constructing a DeclarationName"
283
10.0M
               " from a CXXSpecialNameExtra!");
284
0
    setPtrAndKind(Name, StoredKind);
285
10.0M
  }
286
287
  /// Construct a DeclarationName from a CXXOperatorIdName.
288
6.40M
  DeclarationName(detail::CXXOperatorIdName *Name) {
289
6.40M
    setPtrAndKind(Name, StoredCXXOperatorName);
290
6.40M
  }
291
292
  /// Assert that the stored pointer points to an IdentifierInfo and return it.
293
2.37G
  IdentifierInfo *castAsIdentifierInfo() const {
294
2.37G
    assert((getStoredNameKind() == StoredIdentifier) &&
295
2.37G
           "DeclarationName does not store an IdentifierInfo!");
296
0
    return static_cast<IdentifierInfo *>(getPtr());
297
2.37G
  }
298
299
  /// Assert that the stored pointer points to a DeclarationNameExtra
300
  /// and return it.
301
7.66M
  detail::DeclarationNameExtra *castAsExtra() const {
302
7.66M
    assert((getStoredNameKind() == StoredDeclarationNameExtra) &&
303
7.66M
           "DeclarationName does not store an Extra structure!");
304
0
    return static_cast<detail::DeclarationNameExtra *>(getPtr());
305
7.66M
  }
306
307
  /// Assert that the stored pointer points to a CXXSpecialNameExtra
308
  /// and return it.
309
4.64M
  detail::CXXSpecialNameExtra *castAsCXXSpecialNameExtra() const {
310
4.64M
    assert((getStoredNameKind() == StoredCXXConstructorName ||
311
4.64M
           getStoredNameKind() == StoredCXXDestructorName ||
312
4.64M
           getStoredNameKind() == StoredCXXConversionFunctionName) &&
313
4.64M
               "DeclarationName does not store a CXXSpecialNameExtra!");
314
0
    return static_cast<detail::CXXSpecialNameExtra *>(getPtr());
315
4.64M
  }
316
317
  /// Assert that the stored pointer points to a CXXOperatorIdName
318
  /// and return it.
319
35.3M
  detail::CXXOperatorIdName *castAsCXXOperatorIdName() const {
320
35.3M
    assert((getStoredNameKind() == StoredCXXOperatorName) &&
321
35.3M
           "DeclarationName does not store a CXXOperatorIdName!");
322
0
    return static_cast<detail::CXXOperatorIdName *>(getPtr());
323
35.3M
  }
324
325
  /// Assert that the stored pointer points to a CXXDeductionGuideNameExtra
326
  /// and return it.
327
12.2k
  detail::CXXDeductionGuideNameExtra *castAsCXXDeductionGuideNameExtra() const {
328
12.2k
    assert(getNameKind() == CXXDeductionGuideName &&
329
12.2k
           "DeclarationName does not store a CXXDeductionGuideNameExtra!");
330
0
    return static_cast<detail::CXXDeductionGuideNameExtra *>(getPtr());
331
12.2k
  }
332
333
  /// Assert that the stored pointer points to a CXXLiteralOperatorIdName
334
  /// and return it.
335
9.61k
  detail::CXXLiteralOperatorIdName *castAsCXXLiteralOperatorIdName() const {
336
9.61k
    assert(getNameKind() == CXXLiteralOperatorName &&
337
9.61k
           "DeclarationName does not store a CXXLiteralOperatorIdName!");
338
0
    return static_cast<detail::CXXLiteralOperatorIdName *>(getPtr());
339
9.61k
  }
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
887M
  DeclarationName() { setPtrAndKind(nullptr, StoredIdentifier); }
349
350
  /// Construct a declaration name from an IdentifierInfo *.
351
570M
  DeclarationName(const IdentifierInfo *II) {
352
570M
    setPtrAndKind(II, StoredIdentifier);
353
570M
  }
354
355
  /// Construct a declaration name from an Objective-C selector.
356
13.7M
  DeclarationName(Selector Sel) : Ptr(Sel.InfoPtr) {}
357
358
  /// Returns the name for all C++ using-directives.
359
93.5M
  static DeclarationName getUsingDirectiveName() {
360
    // Single instance of DeclarationNameExtra for using-directive
361
93.5M
    static detail::DeclarationNameExtra UDirExtra(
362
93.5M
        detail::DeclarationNameExtra::CXXUsingDirective);
363
93.5M
    return DeclarationName(&UDirExtra);
364
93.5M
  }
365
366
  /// Evaluates true when this declaration name is non-empty.
367
658M
  explicit operator bool() const {
368
658M
    return getPtr() || 
(getStoredNameKind() != StoredIdentifier)130M
;
369
658M
  }
370
371
  /// Evaluates true when this declaration name is empty.
372
5.63M
  bool isEmpty() const { return !*this; }
373
374
  /// Predicate functions for querying what type of name this is.
375
1.31G
  bool isIdentifier() const { return getStoredNameKind() == StoredIdentifier; }
376
15.4k
  bool isObjCZeroArgSelector() const {
377
15.4k
    return getStoredNameKind() == StoredObjCZeroArgSelector;
378
15.4k
  }
379
5.57k
  bool isObjCOneArgSelector() const {
380
5.57k
    return getStoredNameKind() == StoredObjCOneArgSelector;
381
5.57k
  }
382
383
  /// Determine what kind of name this is.
384
814M
  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
814M
    StoredNameKind StoredKind = getStoredNameKind();
388
814M
    if (StoredKind != StoredDeclarationNameExtra)
389
806M
      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
7.66M
    unsigned ExtraKind = castAsExtra()->getKind();
394
7.66M
    return static_cast<NameKind>(UncommonNameKindOffset + ExtraKind);
395
814M
  }
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
1.29G
  IdentifierInfo *getAsIdentifierInfo() const {
411
1.29G
    if (isIdentifier())
412
1.28G
      return castAsIdentifierInfo();
413
12.9M
    return nullptr;
414
1.29G
  }
415
416
  /// Get the representation of this declaration name as an opaque integer.
417
178k
  uintptr_t getAsOpaqueInteger() const { return Ptr; }
418
419
  /// Get the representation of this declaration name as an opaque pointer.
420
278M
  void *getAsOpaquePtr() const { return reinterpret_cast<void *>(Ptr); }
421
422
  /// Get a declaration name from an opaque pointer returned by getAsOpaquePtr.
423
0
  static DeclarationName getFromOpaquePtr(void *P) {
424
0
    DeclarationName N;
425
0
    N.Ptr = reinterpret_cast<uintptr_t>(P);
426
0
    return N;
427
0
  }
428
429
  /// Get a declaration name from an opaque integer
430
  /// returned by getAsOpaqueInteger.
431
31.4k
  static DeclarationName getFromOpaqueInteger(uintptr_t P) {
432
31.4k
    DeclarationName N;
433
31.4k
    N.Ptr = P;
434
31.4k
    return N;
435
31.4k
  }
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
2.04M
  QualType getCXXNameType() const {
440
2.04M
    if (getStoredNameKind() == StoredCXXConstructorName ||
441
2.04M
        
getStoredNameKind() == StoredCXXDestructorName1.05M
||
442
2.04M
        
getStoredNameKind() == StoredCXXConversionFunctionName993k
) {
443
1.63M
      assert(getPtr() && "getCXXNameType on a null DeclarationName!");
444
0
      return castAsCXXSpecialNameExtra()->Type;
445
1.63M
    }
446
407k
    return QualType();
447
2.04M
  }
448
449
  /// If this name is the name of a C++ deduction guide, return the
450
  /// template associated with that name.
451
416k
  TemplateDecl *getCXXDeductionGuideTemplate() const {
452
416k
    if (getNameKind() == CXXDeductionGuideName) {
453
8.17k
      assert(getPtr() &&
454
8.17k
             "getCXXDeductionGuideTemplate on a null DeclarationName!");
455
0
      return castAsCXXDeductionGuideNameExtra()->Template;
456
8.17k
    }
457
408k
    return nullptr;
458
416k
  }
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
372M
  OverloadedOperatorKind getCXXOverloadedOperator() const {
463
372M
    if (getStoredNameKind() == StoredCXXOperatorName) {
464
30.6M
      assert(getPtr() && "getCXXOverloadedOperator on a null DeclarationName!");
465
0
      return castAsCXXOperatorIdName()->Kind;
466
30.6M
    }
467
341M
    return OO_None;
468
372M
  }
469
470
  /// If this name is the name of a literal operator,
471
  /// retrieve the identifier associated with it.
472
3.80k
  IdentifierInfo *getCXXLiteralIdentifier() const {
473
3.80k
    if (getNameKind() == CXXLiteralOperatorName) {
474
3.80k
      assert(getPtr() && "getCXXLiteralIdentifier on a null DeclarationName!");
475
0
      return castAsCXXLiteralOperatorIdName()->ID;
476
3.80k
    }
477
0
    return nullptr;
478
3.80k
  }
479
480
  /// Get the Objective-C selector stored in this declaration name.
481
17.4M
  Selector getObjCSelector() const {
482
17.4M
    assert((getNameKind() == ObjCZeroArgSelector ||
483
17.4M
            getNameKind() == ObjCOneArgSelector ||
484
17.4M
            getNameKind() == ObjCMultiArgSelector || !getPtr()) &&
485
17.4M
           "Not a selector!");
486
0
    return Selector(Ptr);
487
17.4M
  }
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
959M
  void *getFETokenInfo() const {
493
959M
    assert(getPtr() && "getFETokenInfo on an empty DeclarationName!");
494
959M
    if (getStoredNameKind() == StoredIdentifier)
495
952M
      return castAsIdentifierInfo()->getFETokenInfo();
496
7.13M
    return getFETokenInfoSlow();
497
959M
  }
498
499
118M
  void setFETokenInfo(void *T) {
500
118M
    assert(getPtr() && "setFETokenInfo on an empty DeclarationName!");
501
118M
    if (getStoredNameKind() == StoredIdentifier)
502
117M
      castAsIdentifierInfo()->setFETokenInfo(T);
503
547k
    else
504
547k
      setFETokenInfoSlow(T);
505
118M
  }
506
507
  /// Determine whether the specified names are identical.
508
3.37G
  friend bool operator==(DeclarationName LHS, DeclarationName RHS) {
509
3.37G
    return LHS.Ptr == RHS.Ptr;
510
3.37G
  }
511
512
  /// Determine whether the specified names are different.
513
145k
  friend bool operator!=(DeclarationName LHS, DeclarationName RHS) {
514
145k
    return LHS.Ptr != RHS.Ptr;
515
145k
  }
516
517
304M
  static DeclarationName getEmptyMarker() {
518
304M
    DeclarationName Name;
519
304M
    Name.Ptr = uintptr_t(-1);
520
304M
    return Name;
521
304M
  }
522
523
279M
  static DeclarationName getTombstoneMarker() {
524
279M
    DeclarationName Name;
525
279M
    Name.Ptr = uintptr_t(-2);
526
279M
    return Name;
527
279M
  }
528
529
  static int compare(DeclarationName LHS, DeclarationName RHS);
530
531
  void print(raw_ostream &OS, const PrintingPolicy &Policy) const;
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
9.95M
inline bool operator<(DeclarationName LHS, DeclarationName RHS) {
541
9.95M
  return DeclarationName::compare(LHS, RHS) < 0;
542
9.95M
}
543
544
/// Ordering on two declaration names. If both names are identifiers,
545
/// this provides a lexicographical ordering.
546
0
inline bool operator>(DeclarationName LHS, DeclarationName RHS) {
547
0
  return DeclarationName::compare(LHS, RHS) > 0;
548
0
}
549
550
/// Ordering on two declaration names. If both names are identifiers,
551
/// this provides a lexicographical ordering.
552
0
inline bool operator<=(DeclarationName LHS, DeclarationName RHS) {
553
0
  return DeclarationName::compare(LHS, RHS) <= 0;
554
0
}
555
556
/// Ordering on two declaration names. If both names are identifiers,
557
/// this provides a lexicographical ordering.
558
0
inline bool operator>=(DeclarationName LHS, DeclarationName RHS) {
559
0
  return DeclarationName::compare(LHS, RHS) >= 0;
560
0
}
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
98.9k
  ~DeclarationNameTable() = default;
611
612
  /// Create a declaration name that is a simple identifier.
613
84.6k
  DeclarationName getIdentifier(const IdentifierInfo *ID) {
614
84.6k
    return DeclarationName(ID);
615
84.6k
  }
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
6.40M
  DeclarationName getCXXOperatorName(OverloadedOperatorKind Op) {
640
6.40M
    return DeclarationName(&CXXOperatorNames[Op]);
641
6.40M
  }
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
class 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
    SourceLocation::UIntTy BeginOpNameLoc;
664
    SourceLocation::UIntTy EndOpNameLoc;
665
  };
666
667
  // The location (if any) of the operator keyword is stored elsewhere.
668
  struct CXXLitOpName {
669
    SourceLocation::UIntTy 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
2.55M
  void setNamedTypeLoc(TypeSourceInfo *TInfo) { NamedType.TInfo = TInfo; }
683
684
6.39M
  void setCXXOperatorNameRange(SourceRange Range) {
685
6.39M
    CXXOperatorName.BeginOpNameLoc = Range.getBegin().getRawEncoding();
686
6.39M
    CXXOperatorName.EndOpNameLoc = Range.getEnd().getRawEncoding();
687
6.39M
  }
688
689
3.49k
  void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {
690
3.49k
    CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding();
691
3.49k
  }
692
693
public:
694
  DeclarationNameLoc(DeclarationName Name);
695
  // FIXME: this should go away once all DNLocs are properly initialized.
696
151M
  DeclarationNameLoc() { memset((void*) this, 0, sizeof(*this)); }
697
698
  /// Returns the source type info. Assumes that the object stores location
699
  /// information of a constructor, destructor or conversion operator.
700
1.90M
  TypeSourceInfo *getNamedTypeInfo() const { return NamedType.TInfo; }
701
702
  /// Return the beginning location of the getCXXOperatorNameRange() range.
703
406k
  SourceLocation getCXXOperatorNameBeginLoc() const {
704
406k
    return SourceLocation::getFromRawEncoding(CXXOperatorName.BeginOpNameLoc);
705
406k
  }
706
707
  /// Return the end location of the getCXXOperatorNameRange() range.
708
1.17M
  SourceLocation getCXXOperatorNameEndLoc() const {
709
1.17M
    return SourceLocation::getFromRawEncoding(CXXOperatorName.EndOpNameLoc);
710
1.17M
  }
711
712
  /// Return the range of the operator name (without the operator keyword).
713
  /// Assumes that the object stores location information of a (non-literal)
714
  /// operator.
715
346k
  SourceRange getCXXOperatorNameRange() const {
716
346k
    return SourceRange(getCXXOperatorNameBeginLoc(),
717
346k
                       getCXXOperatorNameEndLoc());
718
346k
  }
719
720
  /// Return the location of the literal operator name (without the operator
721
  /// keyword). Assumes that the object stores location information of a literal
722
  /// operator.
723
1.52k
  SourceLocation getCXXLiteralOperatorNameLoc() const {
724
1.52k
    return SourceLocation::getFromRawEncoding(CXXLiteralOperatorName.OpNameLoc);
725
1.52k
  }
726
727
  /// Construct location information for a constructor, destructor or conversion
728
  /// operator.
729
1.76M
  static DeclarationNameLoc makeNamedTypeLoc(TypeSourceInfo *TInfo) {
730
1.76M
    DeclarationNameLoc DNL;
731
1.76M
    DNL.setNamedTypeLoc(TInfo);
732
1.76M
    return DNL;
733
1.76M
  }
734
735
  /// Construct location information for a non-literal C++ operator.
736
  static DeclarationNameLoc makeCXXOperatorNameLoc(SourceLocation BeginLoc,
737
0
                                                   SourceLocation EndLoc) {
738
0
    return makeCXXOperatorNameLoc(SourceRange(BeginLoc, EndLoc));
739
0
  }
740
741
  /// Construct location information for a non-literal C++ operator.
742
1.85M
  static DeclarationNameLoc makeCXXOperatorNameLoc(SourceRange Range) {
743
1.85M
    DeclarationNameLoc DNL;
744
1.85M
    DNL.setCXXOperatorNameRange(Range);
745
1.85M
    return DNL;
746
1.85M
  }
747
748
  /// Construct location information for a literal C++ operator.
749
2.69k
  static DeclarationNameLoc makeCXXLiteralOperatorNameLoc(SourceLocation Loc) {
750
2.69k
    DeclarationNameLoc DNL;
751
2.69k
    DNL.setCXXLiteralOperatorNameLoc(Loc);
752
2.69k
    return DNL;
753
2.69k
  }
754
};
755
756
/// DeclarationNameInfo - A collector data type for bundling together
757
/// a DeclarationName and the correspnding source/type location info.
758
struct DeclarationNameInfo {
759
private:
760
  /// Name - The declaration name, also encoding name kind.
761
  DeclarationName Name;
762
763
  /// Loc - The main source location for the declaration name.
764
  SourceLocation NameLoc;
765
766
  /// Info - Further source/type location info for special kinds of names.
767
  DeclarationNameLoc LocInfo;
768
769
public:
770
  // FIXME: remove it.
771
142M
  DeclarationNameInfo() = default;
772
773
  DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc)
774
212M
      : Name(Name), NameLoc(NameLoc), LocInfo(Name) {}
775
776
  DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc,
777
                      DeclarationNameLoc LocInfo)
778
130M
      : Name(Name), NameLoc(NameLoc), LocInfo(LocInfo) {}
779
780
  /// getName - Returns the embedded declaration name.
781
1.34G
  DeclarationName getName() const { return Name; }
782
783
  /// setName - Sets the embedded declaration name.
784
123M
  void setName(DeclarationName N) { Name = N; }
785
786
  /// getLoc - Returns the main location of the declaration name.
787
209M
  SourceLocation getLoc() const { return NameLoc; }
788
789
  /// setLoc - Sets the main location of the declaration name.
790
123M
  void setLoc(SourceLocation L) { NameLoc = L; }
791
792
59.7M
  const DeclarationNameLoc &getInfo() const { return LocInfo; }
793
1.02M
  void setInfo(const DeclarationNameLoc &Info) { LocInfo = Info; }
794
795
  /// getNamedTypeInfo - Returns the source type info associated to
796
  /// the name. Assumes it is a constructor, destructor or conversion.
797
754k
  TypeSourceInfo *getNamedTypeInfo() const {
798
754k
    if (Name.getNameKind() != DeclarationName::CXXConstructorName &&
799
754k
        
Name.getNameKind() != DeclarationName::CXXDestructorName109k
&&
800
754k
        
Name.getNameKind() != DeclarationName::CXXConversionFunctionName31.2k
)
801
0
      return nullptr;
802
754k
    return LocInfo.getNamedTypeInfo();
803
754k
  }
804
805
  /// setNamedTypeInfo - Sets the source type info associated to
806
  /// the name. Assumes it is a constructor, destructor or conversion.
807
1.62M
  void setNamedTypeInfo(TypeSourceInfo *TInfo) {
808
1.62M
    assert(Name.getNameKind() == DeclarationName::CXXConstructorName ||
809
1.62M
           Name.getNameKind() == DeclarationName::CXXDestructorName ||
810
1.62M
           Name.getNameKind() == DeclarationName::CXXConversionFunctionName);
811
0
    LocInfo = DeclarationNameLoc::makeNamedTypeLoc(TInfo);
812
1.62M
  }
813
814
  /// getCXXOperatorNameRange - Gets the range of the operator name
815
  /// (without the operator keyword). Assumes it is a (non-literal) operator.
816
229k
  SourceRange getCXXOperatorNameRange() const {
817
229k
    if (Name.getNameKind() != DeclarationName::CXXOperatorName)
818
0
      return SourceRange();
819
229k
    return LocInfo.getCXXOperatorNameRange();
820
229k
  }
821
822
  /// setCXXOperatorNameRange - Sets the range of the operator name
823
  /// (without the operator keyword). Assumes it is a C++ operator.
824
1.44M
  void setCXXOperatorNameRange(SourceRange R) {
825
1.44M
    assert(Name.getNameKind() == DeclarationName::CXXOperatorName);
826
0
    LocInfo = DeclarationNameLoc::makeCXXOperatorNameLoc(R);
827
1.44M
  }
828
829
  /// getCXXLiteralOperatorNameLoc - Returns the location of the literal
830
  /// operator name (not the operator keyword).
831
  /// Assumes it is a literal operator.
832
294
  SourceLocation getCXXLiteralOperatorNameLoc() const {
833
294
    if (Name.getNameKind() != DeclarationName::CXXLiteralOperatorName)
834
0
      return SourceLocation();
835
294
    return LocInfo.getCXXLiteralOperatorNameLoc();
836
294
  }
837
838
  /// setCXXLiteralOperatorNameLoc - Sets the location of the literal
839
  /// operator name (not the operator keyword).
840
  /// Assumes it is a literal operator.
841
2.69k
  void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {
842
2.69k
    assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);
843
0
    LocInfo = DeclarationNameLoc::makeCXXLiteralOperatorNameLoc(Loc);
844
2.69k
  }
845
846
  /// Determine whether this name involves a template parameter.
847
  bool isInstantiationDependent() const;
848
849
  /// Determine whether this name contains an unexpanded
850
  /// parameter pack.
851
  bool containsUnexpandedParameterPack() const;
852
853
  /// getAsString - Retrieve the human-readable string for this name.
854
  std::string getAsString() const;
855
856
  /// printName - Print the human-readable name to a stream.
857
  void printName(raw_ostream &OS, PrintingPolicy Policy) const;
858
859
  /// getBeginLoc - Retrieve the location of the first token.
860
118M
  SourceLocation getBeginLoc() const { return NameLoc; }
861
862
  /// getSourceRange - The range of the declaration name.
863
44.7k
  SourceRange getSourceRange() const LLVM_READONLY {
864
44.7k
    return SourceRange(getBeginLoc(), getEndLoc());
865
44.7k
  }
866
867
46.4M
  SourceLocation getEndLoc() const LLVM_READONLY {
868
46.4M
    SourceLocation EndLoc = getEndLocPrivate();
869
46.4M
    return EndLoc.isValid() ? 
EndLoc45.2M
:
getBeginLoc()1.13M
;
870
46.4M
  }
871
872
private:
873
  SourceLocation getEndLocPrivate() const;
874
};
875
876
/// Insertion operator for partial diagnostics.  This allows binding
877
/// DeclarationName's into a partial diagnostic with <<.
878
inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
879
177k
                                             DeclarationName N) {
880
177k
  PD.AddTaggedVal(N.getAsOpaqueInteger(),
881
177k
                  DiagnosticsEngine::ak_declarationname);
882
177k
  return PD;
883
177k
}
884
885
raw_ostream &operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo);
886
887
} // namespace clang
888
889
namespace llvm {
890
891
/// Define DenseMapInfo so that DeclarationNames can be used as keys
892
/// in DenseMap and DenseSets.
893
template<>
894
struct DenseMapInfo<clang::DeclarationName> {
895
304M
  static inline clang::DeclarationName getEmptyKey() {
896
304M
    return clang::DeclarationName::getEmptyMarker();
897
304M
  }
898
899
279M
  static inline clang::DeclarationName getTombstoneKey() {
900
279M
    return clang::DeclarationName::getTombstoneMarker();
901
279M
  }
902
903
274M
  static unsigned getHashValue(clang::DeclarationName Name) {
904
274M
    return DenseMapInfo<void*>::getHashValue(Name.getAsOpaquePtr());
905
274M
  }
906
907
  static inline bool
908
3.00G
  isEqual(clang::DeclarationName LHS, clang::DeclarationName RHS) {
909
3.00G
    return LHS == RHS;
910
3.00G
  }
911
};
912
913
template <> struct PointerLikeTypeTraits<clang::DeclarationName> {
914
100k
  static inline void *getAsVoidPointer(clang::DeclarationName P) {
915
100k
    return P.getAsOpaquePtr();
916
100k
  }
917
0
  static inline clang::DeclarationName getFromVoidPointer(void *P) {
918
0
    return clang::DeclarationName::getFromOpaquePtr(P);
919
0
  }
920
  static constexpr int NumLowBitsAvailable = 0;
921
};
922
923
} // namespace llvm
924
925
// The definition of AssumedTemplateStorage is factored out of TemplateName to
926
// resolve a cyclic dependency between it and DeclarationName (via Type).
927
namespace clang {
928
929
/// A structure for storing the information associated with a name that has
930
/// been assumed to be a template name (despite finding no TemplateDecls).
931
class AssumedTemplateStorage : public UncommonTemplateNameStorage {
932
  friend class ASTContext;
933
934
  AssumedTemplateStorage(DeclarationName Name)
935
873
      : UncommonTemplateNameStorage(Assumed, 0), Name(Name) {}
936
  DeclarationName Name;
937
938
public:
939
  /// Get the name of the template.
940
346
  DeclarationName getDeclName() const { return Name; }
941
};
942
943
} // namespace clang
944
945
#endif // LLVM_CLANG_AST_DECLARATIONNAME_H