Coverage Report

Created: 2023-11-11 10:31

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/AST/DeclarationName.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- DeclarationName.cpp - Declaration names implementation -------------===//
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 implements the DeclarationName and DeclarationNameTable
10
// classes.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#include "clang/AST/DeclarationName.h"
15
#include "clang/AST/ASTContext.h"
16
#include "clang/AST/Decl.h"
17
#include "clang/AST/DeclBase.h"
18
#include "clang/AST/DeclCXX.h"
19
#include "clang/AST/DeclTemplate.h"
20
#include "clang/AST/OpenMPClause.h"
21
#include "clang/AST/PrettyPrinter.h"
22
#include "clang/AST/Type.h"
23
#include "clang/AST/TypeLoc.h"
24
#include "clang/AST/TypeOrdering.h"
25
#include "clang/Basic/IdentifierTable.h"
26
#include "clang/Basic/LLVM.h"
27
#include "clang/Basic/LangOptions.h"
28
#include "clang/Basic/OperatorKinds.h"
29
#include "clang/Basic/SourceLocation.h"
30
#include "llvm/ADT/FoldingSet.h"
31
#include "llvm/Support/Casting.h"
32
#include "llvm/Support/Compiler.h"
33
#include "llvm/Support/ErrorHandling.h"
34
#include "llvm/Support/raw_ostream.h"
35
#include <algorithm>
36
#include <cassert>
37
#include <cstdint>
38
#include <string>
39
40
using namespace clang;
41
42
24.3k
static int compareInt(unsigned A, unsigned B) {
43
24.3k
  return (A < B ? 
-113.6k
:
(10.6k
A > B10.6k
?
19.73k
:
0961
));
44
24.3k
}
45
46
5.47M
int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
47
5.47M
  if (LHS.getNameKind() != RHS.getNameKind())
48
220k
    return (LHS.getNameKind() < RHS.getNameKind() ? 
-1134k
:
186.2k
);
49
50
5.24M
  switch (LHS.getNameKind()) {
51
5.03M
  case DeclarationName::Identifier: {
52
5.03M
    IdentifierInfo *LII = LHS.castAsIdentifierInfo();
53
5.03M
    IdentifierInfo *RII = RHS.castAsIdentifierInfo();
54
5.03M
    if (!LII)
55
0
      return RII ? -1 : 0;
56
5.03M
    if (!RII)
57
0
      return 1;
58
59
5.03M
    return LII->getName().compare(RII->getName());
60
5.03M
  }
61
62
85.3k
  case DeclarationName::ObjCZeroArgSelector:
63
157k
  case DeclarationName::ObjCOneArgSelector:
64
186k
  case DeclarationName::ObjCMultiArgSelector: {
65
186k
    Selector LHSSelector = LHS.getObjCSelector();
66
186k
    Selector RHSSelector = RHS.getObjCSelector();
67
    // getNumArgs for ZeroArgSelector returns 0, but we still need to compare.
68
186k
    if (LHS.getNameKind() == DeclarationName::ObjCZeroArgSelector &&
69
186k
        
RHS.getNameKind() == DeclarationName::ObjCZeroArgSelector85.3k
) {
70
85.3k
      return LHSSelector.getAsIdentifierInfo()->getName().compare(
71
85.3k
          RHSSelector.getAsIdentifierInfo()->getName());
72
85.3k
    }
73
101k
    unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
74
109k
    for (unsigned I = 0, N = std::min(LN, RN); I != N; 
++I8.18k
) {
75
109k
      if (int Compare = LHSSelector.getNameForSlot(I).compare(
76
109k
              RHSSelector.getNameForSlot(I)))
77
100k
        return Compare;
78
109k
    }
79
80
573
    return compareInt(LN, RN);
81
101k
  }
82
83
1.29k
  case DeclarationName::CXXConstructorName:
84
1.80k
  case DeclarationName::CXXDestructorName:
85
1.80k
  case DeclarationName::CXXConversionFunctionName:
86
1.80k
    if (QualTypeOrdering()(LHS.getCXXNameType(), RHS.getCXXNameType()))
87
916
      return -1;
88
886
    if (QualTypeOrdering()(RHS.getCXXNameType(), LHS.getCXXNameType()))
89
677
      return 1;
90
209
    return 0;
91
92
508
  case DeclarationName::CXXDeductionGuideName:
93
    // We never want to compare deduction guide names for templates from
94
    // different scopes, so just compare the template-name.
95
508
    return compare(LHS.getCXXDeductionGuideTemplate()->getDeclName(),
96
508
                   RHS.getCXXDeductionGuideTemplate()->getDeclName());
97
98
23.8k
  case DeclarationName::CXXOperatorName:
99
23.8k
    return compareInt(LHS.getCXXOverloadedOperator(),
100
23.8k
                      RHS.getCXXOverloadedOperator());
101
102
215
  case DeclarationName::CXXLiteralOperatorName:
103
215
    return LHS.getCXXLiteralIdentifier()->getName().compare(
104
215
        RHS.getCXXLiteralIdentifier()->getName());
105
106
0
  case DeclarationName::CXXUsingDirective:
107
0
    return 0;
108
5.24M
  }
109
110
0
  llvm_unreachable("Invalid DeclarationName Kind!");
111
0
}
112
113
static void printCXXConstructorDestructorName(QualType ClassType,
114
                                              raw_ostream &OS,
115
326k
                                              PrintingPolicy Policy) {
116
  // We know we're printing C++ here. Ensure we print types properly.
117
326k
  Policy.adjustForCPlusPlus();
118
119
326k
  if (const RecordType *ClassRec = ClassType->getAs<RecordType>()) {
120
290k
    ClassRec->getDecl()->printName(OS, Policy);
121
290k
    return;
122
290k
  }
123
35.6k
  if (Policy.SuppressTemplateArgsInCXXConstructors) {
124
35
    if (auto *InjTy = ClassType->getAs<InjectedClassNameType>()) {
125
35
      InjTy->getDecl()->printName(OS, Policy);
126
35
      return;
127
35
    }
128
35
  }
129
35.5k
  ClassType.print(OS, Policy);
130
35.5k
}
131
132
void DeclarationName::print(raw_ostream &OS,
133
3.63M
                            const PrintingPolicy &Policy) const {
134
3.63M
  switch (getNameKind()) {
135
3.03M
  case DeclarationName::Identifier:
136
3.03M
    if (const IdentifierInfo *II = getAsIdentifierInfo()) {
137
3.01M
      StringRef Name = II->getName();
138
      // If this is a mangled OpenMP variant name we strip off the mangling for
139
      // printing. It should not be visible to the user at all.
140
3.01M
      if (II->isMangledOpenMPVariantName()) {
141
444
        std::pair<StringRef, StringRef> NameContextPair =
142
444
            Name.split(getOpenMPVariantManglingSeparatorStr());
143
444
        OS << NameContextPair.first << "["
144
444
           << OMPTraitInfo(NameContextPair.second) << "]";
145
3.01M
      } else {
146
3.01M
        OS << Name;
147
3.01M
      }
148
3.01M
    }
149
3.03M
    return;
150
151
5.42k
  case DeclarationName::ObjCZeroArgSelector:
152
8.28k
  case DeclarationName::ObjCOneArgSelector:
153
8.85k
  case DeclarationName::ObjCMultiArgSelector:
154
8.85k
    getObjCSelector().print(OS);
155
8.85k
    return;
156
157
301k
  case DeclarationName::CXXConstructorName:
158
301k
    return printCXXConstructorDestructorName(getCXXNameType(), OS, Policy);
159
160
24.1k
  case DeclarationName::CXXDestructorName:
161
24.1k
    OS << '~';
162
24.1k
    return printCXXConstructorDestructorName(getCXXNameType(), OS, Policy);
163
164
339
  case DeclarationName::CXXDeductionGuideName:
165
339
    OS << "<deduction guide for ";
166
339
    getCXXDeductionGuideTemplate()->getDeclName().print(OS, Policy);
167
339
    OS << '>';
168
339
    return;
169
170
252k
  case DeclarationName::CXXOperatorName: {
171
252k
    const char *OpName = getOperatorSpelling(getCXXOverloadedOperator());
172
252k
    assert(OpName && "not an overloaded operator");
173
174
252k
    OS << "operator";
175
252k
    if (OpName[0] >= 'a' && 
OpName[0] <= 'z'16.7k
)
176
16.2k
      OS << ' ';
177
252k
    OS << OpName;
178
252k
    return;
179
252k
  }
180
181
149
  case DeclarationName::CXXLiteralOperatorName:
182
149
    OS << "operator\"\"" << getCXXLiteralIdentifier()->getName();
183
149
    return;
184
185
8.28k
  case DeclarationName::CXXConversionFunctionName: {
186
8.28k
    OS << "operator ";
187
8.28k
    QualType Type = getCXXNameType();
188
8.28k
    if (const RecordType *Rec = Type->getAs<RecordType>()) {
189
705
      OS << *Rec->getDecl();
190
705
      return;
191
705
    }
192
    // We know we're printing C++ here, ensure we print 'bool' properly.
193
7.58k
    PrintingPolicy CXXPolicy = Policy;
194
7.58k
    CXXPolicy.adjustForCPlusPlus();
195
7.58k
    Type.print(OS, CXXPolicy);
196
7.58k
    return;
197
8.28k
  }
198
11.6k
  case DeclarationName::CXXUsingDirective:
199
11.6k
    OS << "<using-directive>";
200
11.6k
    return;
201
3.63M
  }
202
203
0
  llvm_unreachable("Unexpected declaration name kind");
204
0
}
205
206
namespace clang {
207
208
1.01M
raw_ostream &operator<<(raw_ostream &OS, DeclarationName N) {
209
1.01M
  LangOptions LO;
210
1.01M
  N.print(OS, PrintingPolicy(LO));
211
1.01M
  return OS;
212
1.01M
}
213
214
} // namespace clang
215
216
2.24M
bool DeclarationName::isDependentName() const {
217
2.24M
  QualType T = getCXXNameType();
218
2.24M
  if (!T.isNull() && 
T->isDependentType()805
)
219
17
    return true;
220
221
  // A class-scope deduction guide in a dependent context has a dependent name.
222
2.24M
  auto *TD = getCXXDeductionGuideTemplate();
223
2.24M
  if (TD && 
TD->getDeclContext()->isDependentContext()0
)
224
0
    return true;
225
226
2.24M
  return false;
227
2.24M
}
228
229
918k
std::string DeclarationName::getAsString() const {
230
918k
  std::string Result;
231
918k
  llvm::raw_string_ostream OS(Result);
232
918k
  OS << *this;
233
918k
  return Result;
234
918k
}
235
236
10.5M
void *DeclarationName::getFETokenInfoSlow() const {
237
10.5M
  switch (getNameKind()) {
238
0
  case Identifier:
239
0
    llvm_unreachable("case Identifier already handled by getFETokenInfo!");
240
3.43M
  case CXXConstructorName:
241
3.71M
  case CXXDestructorName:
242
3.78M
  case CXXConversionFunctionName:
243
3.78M
    return castAsCXXSpecialNameExtra()->FETokenInfo;
244
6.78M
  case CXXOperatorName:
245
6.78M
    return castAsCXXOperatorIdName()->FETokenInfo;
246
9.52k
  case CXXDeductionGuideName:
247
9.52k
    return castAsCXXDeductionGuideNameExtra()->FETokenInfo;
248
6.91k
  case CXXLiteralOperatorName:
249
6.91k
    return castAsCXXLiteralOperatorIdName()->FETokenInfo;
250
0
  default:
251
0
    llvm_unreachable("DeclarationName has no FETokenInfo!");
252
10.5M
  }
253
10.5M
}
254
255
785k
void DeclarationName::setFETokenInfoSlow(void *T) {
256
785k
  switch (getNameKind()) {
257
0
  case Identifier:
258
0
    llvm_unreachable("case Identifier already handled by setFETokenInfo!");
259
393k
  case CXXConstructorName:
260
540k
  case CXXDestructorName:
261
573k
  case CXXConversionFunctionName:
262
573k
    castAsCXXSpecialNameExtra()->FETokenInfo = T;
263
573k
    break;
264
208k
  case CXXOperatorName:
265
208k
    castAsCXXOperatorIdName()->FETokenInfo = T;
266
208k
    break;
267
2.23k
  case CXXDeductionGuideName:
268
2.23k
    castAsCXXDeductionGuideNameExtra()->FETokenInfo = T;
269
2.23k
    break;
270
1.23k
  case CXXLiteralOperatorName:
271
1.23k
    castAsCXXLiteralOperatorIdName()->FETokenInfo = T;
272
1.23k
    break;
273
0
  default:
274
0
    llvm_unreachable("DeclarationName has no FETokenInfo!");
275
785k
  }
276
785k
}
277
278
0
LLVM_DUMP_METHOD void DeclarationName::dump() const {
279
0
  llvm::errs() << *this << '\n';
280
0
}
281
282
97.6k
DeclarationNameTable::DeclarationNameTable(const ASTContext &C) : Ctx(C) {
283
  // Initialize the overloaded operator names.
284
4.58M
  for (unsigned Op = 0; Op < NUM_OVERLOADED_OPERATORS; 
++Op4.49M
)
285
4.49M
    CXXOperatorNames[Op].Kind = static_cast<OverloadedOperatorKind>(Op);
286
97.6k
}
287
288
DeclarationName
289
8.75k
DeclarationNameTable::getCXXDeductionGuideName(TemplateDecl *Template) {
290
8.75k
  Template = cast<TemplateDecl>(Template->getCanonicalDecl());
291
292
8.75k
  llvm::FoldingSetNodeID ID;
293
8.75k
  ID.AddPointer(Template);
294
295
8.75k
  void *InsertPos = nullptr;
296
8.75k
  if (auto *Name = CXXDeductionGuideNames.FindNodeOrInsertPos(ID, InsertPos))
297
7.49k
    return DeclarationName(Name);
298
299
1.25k
  auto *Name = new (Ctx) detail::CXXDeductionGuideNameExtra(Template);
300
1.25k
  CXXDeductionGuideNames.InsertNode(Name, InsertPos);
301
1.25k
  return DeclarationName(Name);
302
8.75k
}
303
304
3.39M
DeclarationName DeclarationNameTable::getCXXConstructorName(CanQualType Ty) {
305
  // The type of constructors is unqualified.
306
3.39M
  Ty = Ty.getUnqualifiedType();
307
  // Do we already have this C++ constructor name ?
308
3.39M
  llvm::FoldingSetNodeID ID;
309
3.39M
  ID.AddPointer(Ty.getAsOpaquePtr());
310
3.39M
  void *InsertPos = nullptr;
311
3.39M
  if (auto *Name = CXXConstructorNames.FindNodeOrInsertPos(ID, InsertPos))
312
3.04M
    return {Name, DeclarationName::StoredCXXConstructorName};
313
314
  // We have to create it.
315
349k
  auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
316
349k
  CXXConstructorNames.InsertNode(SpecialName, InsertPos);
317
349k
  return {SpecialName, DeclarationName::StoredCXXConstructorName};
318
3.39M
}
319
320
7.84M
DeclarationName DeclarationNameTable::getCXXDestructorName(CanQualType Ty) {
321
  // The type of destructors is unqualified.
322
7.84M
  Ty = Ty.getUnqualifiedType();
323
  // Do we already have this C++ destructor name ?
324
7.84M
  llvm::FoldingSetNodeID ID;
325
7.84M
  ID.AddPointer(Ty.getAsOpaquePtr());
326
7.84M
  void *InsertPos = nullptr;
327
7.84M
  if (auto *Name = CXXDestructorNames.FindNodeOrInsertPos(ID, InsertPos))
328
6.34M
    return {Name, DeclarationName::StoredCXXDestructorName};
329
330
  // We have to create it.
331
1.50M
  auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
332
1.50M
  CXXDestructorNames.InsertNode(SpecialName, InsertPos);
333
1.50M
  return {SpecialName, DeclarationName::StoredCXXDestructorName};
334
7.84M
}
335
336
DeclarationName
337
100k
DeclarationNameTable::getCXXConversionFunctionName(CanQualType Ty) {
338
  // Do we already have this C++ conversion function name ?
339
100k
  llvm::FoldingSetNodeID ID;
340
100k
  ID.AddPointer(Ty.getAsOpaquePtr());
341
100k
  void *InsertPos = nullptr;
342
100k
  if (auto *Name =
343
100k
          CXXConversionFunctionNames.FindNodeOrInsertPos(ID, InsertPos))
344
82.7k
    return {Name, DeclarationName::StoredCXXConversionFunctionName};
345
346
  // We have to create it.
347
18.2k
  auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
348
18.2k
  CXXConversionFunctionNames.InsertNode(SpecialName, InsertPos);
349
18.2k
  return {SpecialName, DeclarationName::StoredCXXConversionFunctionName};
350
100k
}
351
352
DeclarationName
353
DeclarationNameTable::getCXXSpecialName(DeclarationName::NameKind Kind,
354
416k
                                        CanQualType Ty) {
355
416k
  switch (Kind) {
356
370k
  case DeclarationName::CXXConstructorName:
357
370k
    return getCXXConstructorName(Ty);
358
29.3k
  case DeclarationName::CXXDestructorName:
359
29.3k
    return getCXXDestructorName(Ty);
360
16.3k
  case DeclarationName::CXXConversionFunctionName:
361
16.3k
    return getCXXConversionFunctionName(Ty);
362
0
  default:
363
0
    llvm_unreachable("Invalid kind in getCXXSpecialName!");
364
416k
  }
365
416k
}
366
367
DeclarationName
368
3.73k
DeclarationNameTable::getCXXLiteralOperatorName(const IdentifierInfo *II) {
369
3.73k
  llvm::FoldingSetNodeID ID;
370
3.73k
  ID.AddPointer(II);
371
372
3.73k
  void *InsertPos = nullptr;
373
3.73k
  if (auto *Name = CXXLiteralOperatorNames.FindNodeOrInsertPos(ID, InsertPos))
374
3.13k
    return DeclarationName(Name);
375
376
600
  auto *LiteralName = new (Ctx) detail::CXXLiteralOperatorIdName(II);
377
600
  CXXLiteralOperatorNames.InsertNode(LiteralName, InsertPos);
378
600
  return DeclarationName(LiteralName);
379
3.73k
}
380
381
241M
DeclarationNameLoc::DeclarationNameLoc(DeclarationName Name) {
382
241M
  switch (Name.getNameKind()) {
383
234M
  case DeclarationName::Identifier:
384
234M
  case DeclarationName::CXXDeductionGuideName:
385
234M
    break;
386
746k
  case DeclarationName::CXXConstructorName:
387
999k
  case DeclarationName::CXXDestructorName:
388
1.00M
  case DeclarationName::CXXConversionFunctionName:
389
1.00M
    setNamedTypeLoc(nullptr);
390
1.00M
    break;
391
6.45M
  case DeclarationName::CXXOperatorName:
392
6.45M
    setCXXOperatorNameRange(SourceRange());
393
6.45M
    break;
394
857
  case DeclarationName::CXXLiteralOperatorName:
395
857
    setCXXLiteralOperatorNameLoc(SourceLocation());
396
857
    break;
397
0
  case DeclarationName::ObjCZeroArgSelector:
398
0
  case DeclarationName::ObjCOneArgSelector:
399
0
  case DeclarationName::ObjCMultiArgSelector:
400
    // FIXME: ?
401
0
    break;
402
0
  case DeclarationName::CXXUsingDirective:
403
0
    break;
404
241M
  }
405
241M
}
406
407
9.95M
bool DeclarationNameInfo::containsUnexpandedParameterPack() const {
408
9.95M
  switch (Name.getNameKind()) {
409
8.75M
  case DeclarationName::Identifier:
410
8.75M
  case DeclarationName::ObjCZeroArgSelector:
411
8.75M
  case DeclarationName::ObjCOneArgSelector:
412
8.75M
  case DeclarationName::ObjCMultiArgSelector:
413
9.94M
  case DeclarationName::CXXOperatorName:
414
9.94M
  case DeclarationName::CXXLiteralOperatorName:
415
9.94M
  case DeclarationName::CXXUsingDirective:
416
9.94M
  case DeclarationName::CXXDeductionGuideName:
417
9.94M
    return false;
418
419
28
  case DeclarationName::CXXConstructorName:
420
1.36k
  case DeclarationName::CXXDestructorName:
421
14.8k
  case DeclarationName::CXXConversionFunctionName:
422
14.8k
    if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo())
423
1.53k
      return TInfo->getType()->containsUnexpandedParameterPack();
424
425
13.3k
    return Name.getCXXNameType()->containsUnexpandedParameterPack();
426
9.95M
  }
427
0
  llvm_unreachable("All name kinds handled.");
428
0
}
429
430
9.95M
bool DeclarationNameInfo::isInstantiationDependent() const {
431
9.95M
  switch (Name.getNameKind()) {
432
8.75M
  case DeclarationName::Identifier:
433
8.75M
  case DeclarationName::ObjCZeroArgSelector:
434
8.75M
  case DeclarationName::ObjCOneArgSelector:
435
8.75M
  case DeclarationName::ObjCMultiArgSelector:
436
9.94M
  case DeclarationName::CXXOperatorName:
437
9.94M
  case DeclarationName::CXXLiteralOperatorName:
438
9.94M
  case DeclarationName::CXXUsingDirective:
439
9.94M
  case DeclarationName::CXXDeductionGuideName:
440
9.94M
    return false;
441
442
28
  case DeclarationName::CXXConstructorName:
443
1.36k
  case DeclarationName::CXXDestructorName:
444
14.8k
  case DeclarationName::CXXConversionFunctionName:
445
14.8k
    if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo())
446
1.53k
      return TInfo->getType()->isInstantiationDependentType();
447
448
13.3k
    return Name.getCXXNameType()->isInstantiationDependentType();
449
9.95M
  }
450
0
  llvm_unreachable("All name kinds handled.");
451
0
}
452
453
210k
std::string DeclarationNameInfo::getAsString() const {
454
210k
  std::string Result;
455
210k
  llvm::raw_string_ostream OS(Result);
456
210k
  OS << *this;
457
210k
  return Result;
458
210k
}
459
460
226k
raw_ostream &clang::operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo) {
461
226k
  LangOptions LO;
462
226k
  DNInfo.printName(OS, PrintingPolicy(LangOptions()));
463
226k
  return OS;
464
226k
}
465
466
335k
void DeclarationNameInfo::printName(raw_ostream &OS, PrintingPolicy Policy) const {
467
335k
  switch (Name.getNameKind()) {
468
274k
  case DeclarationName::Identifier:
469
274k
  case DeclarationName::ObjCZeroArgSelector:
470
274k
  case DeclarationName::ObjCOneArgSelector:
471
274k
  case DeclarationName::ObjCMultiArgSelector:
472
316k
  case DeclarationName::CXXOperatorName:
473
316k
  case DeclarationName::CXXLiteralOperatorName:
474
316k
  case DeclarationName::CXXUsingDirective:
475
316k
  case DeclarationName::CXXDeductionGuideName:
476
316k
    Name.print(OS, Policy);
477
316k
    return;
478
479
17.6k
  case DeclarationName::CXXConstructorName:
480
18.3k
  case DeclarationName::CXXDestructorName:
481
19.0k
  case DeclarationName::CXXConversionFunctionName:
482
19.0k
    if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo()) {
483
1.18k
      if (Name.getNameKind() == DeclarationName::CXXDestructorName)
484
679
        OS << '~';
485
503
      else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
486
503
        OS << "operator ";
487
1.18k
      LangOptions LO;
488
1.18k
      Policy.adjustForCPlusPlus();
489
1.18k
      Policy.SuppressScope = true;
490
1.18k
      OS << TInfo->getType().getAsString(Policy);
491
1.18k
    } else
492
17.8k
      Name.print(OS, Policy);
493
19.0k
    return;
494
335k
  }
495
0
  llvm_unreachable("Unexpected declaration name kind");
496
0
}
497
498
58.6M
SourceLocation DeclarationNameInfo::getEndLocPrivate() const {
499
58.6M
  switch (Name.getNameKind()) {
500
56.1M
  case DeclarationName::Identifier:
501
56.1M
  case DeclarationName::CXXDeductionGuideName:
502
56.1M
    return NameLoc;
503
504
1.08M
  case DeclarationName::CXXOperatorName:
505
1.08M
    return LocInfo.getCXXOperatorNameEndLoc();
506
507
1.54k
  case DeclarationName::CXXLiteralOperatorName:
508
1.54k
    return LocInfo.getCXXLiteralOperatorNameLoc();
509
510
1.18M
  case DeclarationName::CXXConstructorName:
511
1.40M
  case DeclarationName::CXXDestructorName:
512
1.46M
  case DeclarationName::CXXConversionFunctionName:
513
1.46M
    if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo())
514
143k
      return TInfo->getTypeLoc().getEndLoc();
515
1.32M
    else
516
1.32M
      return NameLoc;
517
518
    // DNInfo work in progress: FIXME.
519
0
  case DeclarationName::ObjCZeroArgSelector:
520
0
  case DeclarationName::ObjCOneArgSelector:
521
0
  case DeclarationName::ObjCMultiArgSelector:
522
0
  case DeclarationName::CXXUsingDirective:
523
0
    return NameLoc;
524
58.6M
  }
525
0
  llvm_unreachable("Unexpected declaration name kind");
526
0
}