Coverage Report

Created: 2023-11-11 10:31

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Index/IndexSymbol.cpp
Line
Count
Source (jump to first uncovered line)
1
//===--- IndexSymbol.cpp - Types and functions for indexing symbols -------===//
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
#include "clang/Index/IndexSymbol.h"
10
#include "clang/AST/Attr.h"
11
#include "clang/AST/DeclCXX.h"
12
#include "clang/AST/DeclObjC.h"
13
#include "clang/AST/DeclTemplate.h"
14
#include "clang/AST/PrettyPrinter.h"
15
#include "clang/Lex/MacroInfo.h"
16
17
using namespace clang;
18
using namespace clang::index;
19
20
/// \returns true if \c D is a subclass of 'XCTestCase'.
21
212
static bool isUnitTestCase(const ObjCInterfaceDecl *D) {
22
212
  if (!D)
23
0
    return false;
24
245
  
while (const ObjCInterfaceDecl *212
SuperD = D->getSuperClass()) {
25
45
    if (SuperD->getName() == "XCTestCase")
26
12
      return true;
27
33
    D = SuperD;
28
33
  }
29
200
  return false;
30
212
}
31
32
/// \returns true if \c D is in a subclass of 'XCTestCase', returns void, has
33
/// no parameters, and its name starts with 'test'.
34
258
static bool isUnitTest(const ObjCMethodDecl *D) {
35
258
  if (!D->parameters().empty())
36
114
    return false;
37
144
  if (!D->getReturnType()->isVoidType())
38
102
    return false;
39
42
  if (!D->getSelector().getNameForSlot(0).startswith("test"))
40
39
    return false;
41
3
  return isUnitTestCase(D->getClassInterface());
42
42
}
43
44
98
static void checkForIBOutlets(const Decl *D, SymbolPropertySet &PropSet) {
45
98
  if (D->hasAttr<IBOutletAttr>()) {
46
1
    PropSet |= (SymbolPropertySet)SymbolProperty::IBAnnotated;
47
97
  } else if (D->hasAttr<IBOutletCollectionAttr>()) {
48
8
    PropSet |= (SymbolPropertySet)SymbolProperty::IBAnnotated;
49
8
    PropSet |= (SymbolPropertySet)SymbolProperty::IBOutletCollection;
50
8
  }
51
98
}
52
53
11.2k
bool index::isFunctionLocalSymbol(const Decl *D) {
54
11.2k
  assert(D);
55
56
11.2k
  if (isa<ParmVarDecl>(D))
57
2.08k
    return true;
58
59
9.13k
  if (isa<ObjCTypeParamDecl>(D))
60
0
    return true;
61
62
9.13k
  if (isa<UsingDirectiveDecl>(D))
63
2
    return false;
64
9.13k
  if (!D->getParentFunctionOrMethod())
65
8.90k
    return false;
66
67
224
  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
68
223
    switch (ND->getFormalLinkage()) {
69
0
    case Linkage::Invalid:
70
0
      llvm_unreachable("Linkage hasn't been computed!");
71
223
    case Linkage::None:
72
223
    case Linkage::Internal:
73
223
      return true;
74
0
    case Linkage::VisibleNone:
75
0
    case Linkage::UniqueExternal:
76
0
      llvm_unreachable("Not a sema linkage");
77
0
    case Linkage::Module:
78
0
    case Linkage::External:
79
0
      return false;
80
223
    }
81
223
  }
82
83
1
  return true;
84
224
}
85
86
5.76k
SymbolInfo index::getSymbolInfo(const Decl *D) {
87
5.76k
  assert(D);
88
5.76k
  SymbolInfo Info;
89
5.76k
  Info.Kind = SymbolKind::Unknown;
90
5.76k
  Info.SubKind = SymbolSubKind::None;
91
5.76k
  Info.Properties = SymbolPropertySet();
92
5.76k
  Info.Lang = SymbolLanguage::C;
93
94
5.76k
  if (isFunctionLocalSymbol(D)) {
95
112
    Info.Properties |= (SymbolPropertySet)SymbolProperty::Local;
96
112
  }
97
5.76k
  if (isa<ObjCProtocolDecl>(D->getDeclContext())) {
98
7
    Info.Properties |= (SymbolPropertySet)SymbolProperty::ProtocolInterface;
99
7
  }
100
101
5.76k
  if (auto *VT = dyn_cast<VarTemplateDecl>(D)) {
102
0
    Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
103
0
    Info.Lang = SymbolLanguage::CXX;
104
    // All other fields are filled from the templated decl.
105
0
    D = VT->getTemplatedDecl();
106
0
  }
107
108
5.76k
  if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
109
542
    switch (TD->getTagKind()) {
110
239
    case TagTypeKind::Struct:
111
239
      Info.Kind = SymbolKind::Struct; break;
112
5
    case TagTypeKind::Union:
113
5
      Info.Kind = SymbolKind::Union; break;
114
269
    case TagTypeKind::Class:
115
269
      Info.Kind = SymbolKind::Class;
116
269
      Info.Lang = SymbolLanguage::CXX;
117
269
      break;
118
0
    case TagTypeKind::Interface:
119
0
      Info.Kind = SymbolKind::Protocol;
120
0
      Info.Lang = SymbolLanguage::CXX;
121
0
      break;
122
29
    case TagTypeKind::Enum:
123
29
      Info.Kind = SymbolKind::Enum; break;
124
542
    }
125
126
542
    if (const CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(D)) {
127
492
      if (!CXXRec->isCLike()) {
128
437
        Info.Lang = SymbolLanguage::CXX;
129
437
        if (CXXRec->getDescribedClassTemplate()) {
130
177
          Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
131
177
        }
132
437
      }
133
492
    }
134
135
542
    if (isa<ClassTemplatePartialSpecializationDecl>(D)) {
136
25
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
137
25
      Info.Properties |=
138
25
          (SymbolPropertySet)SymbolProperty::TemplatePartialSpecialization;
139
517
    } else if (isa<ClassTemplateSpecializationDecl>(D)) {
140
45
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
141
45
      Info.Properties |=
142
45
          (SymbolPropertySet)SymbolProperty::TemplateSpecialization;
143
45
    }
144
145
5.22k
  } else if (auto *VD = dyn_cast<VarDecl>(D)) {
146
251
    Info.Kind = SymbolKind::Variable;
147
251
    if (isa<ParmVarDecl>(D)) {
148
37
      Info.Kind = SymbolKind::Parameter;
149
214
    } else if (isa<CXXRecordDecl>(D->getDeclContext())) {
150
27
      Info.Kind = SymbolKind::StaticProperty;
151
27
      Info.Lang = SymbolLanguage::CXX;
152
27
    }
153
154
251
    if (isa<VarTemplatePartialSpecializationDecl>(D)) {
155
0
      Info.Lang = SymbolLanguage::CXX;
156
0
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
157
0
      Info.Properties |=
158
0
          (SymbolPropertySet)SymbolProperty::TemplatePartialSpecialization;
159
251
    } else if (isa<VarTemplateSpecializationDecl>(D)) {
160
4
      Info.Lang = SymbolLanguage::CXX;
161
4
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
162
4
      Info.Properties |=
163
4
          (SymbolPropertySet)SymbolProperty::TemplateSpecialization;
164
247
    } else if (VD->getDescribedVarTemplate()) {
165
8
      Info.Lang = SymbolLanguage::CXX;
166
8
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
167
8
    }
168
169
4.97k
  } else {
170
4.97k
    switch (D->getKind()) {
171
9
    case Decl::Import:
172
9
      Info.Kind = SymbolKind::Module;
173
9
      break;
174
144
    case Decl::Typedef:
175
144
      Info.Kind = SymbolKind::TypeAlias; break; // Lang = C
176
2.00k
    case Decl::Function:
177
2.00k
      Info.Kind = SymbolKind::Function;
178
2.00k
      break;
179
75
    case Decl::Field:
180
75
    case Decl::IndirectField:
181
75
      Info.Kind = SymbolKind::Field;
182
75
      if (const CXXRecordDecl *
183
75
            CXXRec = dyn_cast<CXXRecordDecl>(D->getDeclContext())) {
184
63
        if (!CXXRec->isCLike())
185
37
          Info.Lang = SymbolLanguage::CXX;
186
63
      }
187
75
      break;
188
36
    case Decl::EnumConstant:
189
36
      Info.Kind = SymbolKind::EnumConstant; break;
190
175
    case Decl::ObjCInterface:
191
191
    case Decl::ObjCImplementation: {
192
191
      Info.Kind = SymbolKind::Class;
193
191
      Info.Lang = SymbolLanguage::ObjC;
194
191
      const ObjCInterfaceDecl *ClsD = dyn_cast<ObjCInterfaceDecl>(D);
195
191
      if (!ClsD)
196
16
        ClsD = cast<ObjCImplementationDecl>(D)->getClassInterface();
197
191
      if (isUnitTestCase(ClsD))
198
7
        Info.Properties |= (SymbolPropertySet)SymbolProperty::UnitTest;
199
191
      break;
200
175
    }
201
56
    case Decl::ObjCProtocol:
202
56
      Info.Kind = SymbolKind::Protocol;
203
56
      Info.Lang = SymbolLanguage::ObjC;
204
56
      break;
205
15
    case Decl::ObjCCategory:
206
18
    case Decl::ObjCCategoryImpl: {
207
18
      Info.Kind = SymbolKind::Extension;
208
18
      Info.Lang = SymbolLanguage::ObjC;
209
18
      const ObjCInterfaceDecl *ClsD = nullptr;
210
18
      if (auto *CatD = dyn_cast<ObjCCategoryDecl>(D))
211
15
        ClsD = CatD->getClassInterface();
212
3
      else
213
3
        ClsD = cast<ObjCCategoryImplDecl>(D)->getClassInterface();
214
18
      if (isUnitTestCase(ClsD))
215
2
        Info.Properties |= (SymbolPropertySet)SymbolProperty::UnitTest;
216
18
      break;
217
15
    }
218
258
    case Decl::ObjCMethod: {
219
258
      const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(D);
220
258
      Info.Kind = MD->isInstanceMethod() ? 
SymbolKind::InstanceMethod215
:
SymbolKind::ClassMethod43
;
221
258
      if (MD->isPropertyAccessor()) {
222
136
        if (MD->param_size())
223
64
          Info.SubKind = SymbolSubKind::AccessorSetter;
224
72
        else
225
72
          Info.SubKind = SymbolSubKind::AccessorGetter;
226
136
      }
227
258
      Info.Lang = SymbolLanguage::ObjC;
228
258
      if (isUnitTest(MD))
229
3
        Info.Properties |= (SymbolPropertySet)SymbolProperty::UnitTest;
230
258
      if (D->hasAttr<IBActionAttr>())
231
3
        Info.Properties |= (SymbolPropertySet)SymbolProperty::IBAnnotated;
232
258
      break;
233
15
    }
234
65
    case Decl::ObjCProperty:
235
65
      Info.Kind = SymbolKind::InstanceProperty;
236
65
      Info.Lang = SymbolLanguage::ObjC;
237
65
      checkForIBOutlets(D, Info.Properties);
238
65
      if (auto *Annot = D->getAttr<AnnotateAttr>()) {
239
2
        if (Annot->getAnnotation() == "gk_inspectable")
240
1
          Info.Properties |= (SymbolPropertySet)SymbolProperty::GKInspectable;
241
2
      }
242
65
      break;
243
33
    case Decl::ObjCIvar:
244
33
      Info.Kind = SymbolKind::Field;
245
33
      Info.Lang = SymbolLanguage::ObjC;
246
33
      checkForIBOutlets(D, Info.Properties);
247
33
      break;
248
60
    case Decl::Namespace:
249
60
      Info.Kind = SymbolKind::Namespace;
250
60
      Info.Lang = SymbolLanguage::CXX;
251
60
      break;
252
10
    case Decl::NamespaceAlias:
253
10
      Info.Kind = SymbolKind::NamespaceAlias;
254
10
      Info.Lang = SymbolLanguage::CXX;
255
10
      break;
256
39
    case Decl::CXXConstructor: {
257
39
      Info.Kind = SymbolKind::Constructor;
258
39
      Info.Lang = SymbolLanguage::CXX;
259
39
      auto *CD = cast<CXXConstructorDecl>(D);
260
39
      if (CD->isCopyConstructor())
261
10
        Info.SubKind = SymbolSubKind::CXXCopyConstructor;
262
29
      else if (CD->isMoveConstructor())
263
4
        Info.SubKind = SymbolSubKind::CXXMoveConstructor;
264
39
      break;
265
15
    }
266
8
    case Decl::CXXDestructor:
267
8
      Info.Kind = SymbolKind::Destructor;
268
8
      Info.Lang = SymbolLanguage::CXX;
269
8
      break;
270
0
    case Decl::CXXConversion:
271
0
      Info.Kind = SymbolKind::ConversionFunction;
272
0
      Info.Lang = SymbolLanguage::CXX;
273
0
      break;
274
1.87k
    case Decl::CXXMethod: {
275
1.87k
      const CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
276
1.87k
      if (MD->isStatic())
277
11
        Info.Kind = SymbolKind::StaticMethod;
278
1.86k
      else
279
1.86k
        Info.Kind = SymbolKind::InstanceMethod;
280
1.87k
      Info.Lang = SymbolLanguage::CXX;
281
1.87k
      break;
282
15
    }
283
22
    case Decl::ClassTemplate:
284
22
      Info.Kind = SymbolKind::Class;
285
22
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
286
22
      Info.Lang = SymbolLanguage::CXX;
287
22
      break;
288
4
    case Decl::FunctionTemplate:
289
4
      Info.Kind = SymbolKind::Function;
290
4
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
291
4
      Info.Lang = SymbolLanguage::CXX;
292
4
      if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(
293
4
                           cast<FunctionTemplateDecl>(D)->getTemplatedDecl())) {
294
0
        if (isa<CXXConstructorDecl>(MD))
295
0
          Info.Kind = SymbolKind::Constructor;
296
0
        else if (isa<CXXDestructorDecl>(MD))
297
0
          Info.Kind = SymbolKind::Destructor;
298
0
        else if (isa<CXXConversionDecl>(MD))
299
0
          Info.Kind = SymbolKind::ConversionFunction;
300
0
        else {
301
0
          if (MD->isStatic())
302
0
            Info.Kind = SymbolKind::StaticMethod;
303
0
          else
304
0
            Info.Kind = SymbolKind::InstanceMethod;
305
0
        }
306
0
      }
307
4
      break;
308
0
    case Decl::TypeAliasTemplate:
309
0
      Info.Kind = SymbolKind::TypeAlias;
310
0
      Info.Lang = SymbolLanguage::CXX;
311
0
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
312
0
      break;
313
28
    case Decl::TypeAlias:
314
28
      Info.Kind = SymbolKind::TypeAlias;
315
28
      Info.Lang = SymbolLanguage::CXX;
316
28
      break;
317
2
    case Decl::UnresolvedUsingTypename:
318
2
      Info.Kind = SymbolKind::Using;
319
2
      Info.SubKind = SymbolSubKind::UsingTypename;
320
2
      Info.Lang = SymbolLanguage::CXX;
321
2
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
322
2
      break;
323
6
    case Decl::UnresolvedUsingValue:
324
6
      Info.Kind = SymbolKind::Using;
325
6
      Info.SubKind = SymbolSubKind::UsingValue;
326
6
      Info.Lang = SymbolLanguage::CXX;
327
6
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
328
6
      break;
329
2
    case Decl::Using:
330
2
      Info.Kind = SymbolKind::Using;
331
2
      Info.Lang = SymbolLanguage::CXX;
332
2
      break;
333
0
    case Decl::UsingEnum:
334
0
      Info.Kind = SymbolKind::Using;
335
0
      Info.Lang = SymbolLanguage::CXX;
336
0
      Info.SubKind = SymbolSubKind::UsingEnum;
337
0
      break;
338
12
    case Decl::Binding:
339
12
      Info.Kind = SymbolKind::Variable;
340
12
      Info.Lang = SymbolLanguage::CXX;
341
12
      break;
342
3
    case Decl::MSProperty:
343
3
      Info.Kind = SymbolKind::InstanceProperty;
344
3
      if (const CXXRecordDecl *CXXRec =
345
3
              dyn_cast<CXXRecordDecl>(D->getDeclContext())) {
346
3
        if (!CXXRec->isCLike())
347
3
          Info.Lang = SymbolLanguage::CXX;
348
3
      }
349
3
      break;
350
0
    case Decl::ClassTemplatePartialSpecialization:
351
0
    case Decl::ClassTemplateSpecialization:
352
0
    case Decl::CXXRecord:
353
0
    case Decl::Enum:
354
0
    case Decl::Record:
355
0
      llvm_unreachable("records handled before");
356
0
      break;
357
0
    case Decl::VarTemplateSpecialization:
358
0
    case Decl::VarTemplatePartialSpecialization:
359
0
    case Decl::ImplicitParam:
360
0
    case Decl::ParmVar:
361
0
    case Decl::Var:
362
0
    case Decl::VarTemplate:
363
0
      llvm_unreachable("variables handled before");
364
0
      break;
365
3
    case Decl::TemplateTypeParm:
366
3
      Info.Kind = SymbolKind::TemplateTypeParm;
367
3
      break;
368
2
    case Decl::TemplateTemplateParm:
369
2
      Info.Kind = SymbolKind::TemplateTemplateParm;
370
2
      break;
371
2
    case Decl::NonTypeTemplateParm:
372
2
      Info.Kind = SymbolKind::NonTypeTemplateParm;
373
2
      break;
374
2
    case Decl::Concept:
375
2
      Info.Kind = SymbolKind::Concept;
376
2
      break;
377
    // Other decls get the 'unknown' kind.
378
2
    default:
379
2
      break;
380
4.97k
    }
381
4.97k
  }
382
383
5.76k
  if (Info.Kind == SymbolKind::Unknown)
384
2
    return Info;
385
386
5.76k
  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
387
3.92k
    if (FD->getTemplatedKind() ==
388
3.92k
          FunctionDecl::TK_FunctionTemplateSpecialization) {
389
12
      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
390
12
      Info.Properties |=
391
12
          (SymbolPropertySet)SymbolProperty::TemplateSpecialization;
392
12
    }
393
3.92k
  }
394
395
5.76k
  if (Info.Properties & (SymbolPropertySet)SymbolProperty::Generic)
396
305
    Info.Lang = SymbolLanguage::CXX;
397
398
5.76k
  if (auto *attr = D->getExternalSourceSymbolAttr()) {
399
34
    if (attr->getLanguage() == "Swift")
400
34
      Info.Lang = SymbolLanguage::Swift;
401
34
  }
402
403
5.76k
  return Info;
404
5.76k
}
405
406
22.3k
SymbolInfo index::getSymbolInfoForMacro(const MacroInfo &) {
407
22.3k
  SymbolInfo Info;
408
22.3k
  Info.Kind = SymbolKind::Macro;
409
22.3k
  Info.SubKind = SymbolSubKind::None;
410
22.3k
  Info.Properties = SymbolPropertySet();
411
22.3k
  Info.Lang = SymbolLanguage::C;
412
22.3k
  return Info;
413
22.3k
}
414
415
bool index::applyForEachSymbolRoleInterruptible(SymbolRoleSet Roles,
416
24.4k
                                   llvm::function_ref<bool(SymbolRole)> Fn) {
417
24.4k
#define APPLY_FOR_ROLE(Role) \
418
513k
  if (Roles & (unsigned)SymbolRole::Role) \
419
513k
    
if (26.3k
!Fn(SymbolRole::Role)26.3k
) \
420
26.3k
      
return false7
;
421
422
24.4k
  APPLY_FOR_ROLE(Declaration);
423
24.4k
  APPLY_FOR_ROLE(Definition);
424
24.4k
  APPLY_FOR_ROLE(Reference);
425
24.4k
  APPLY_FOR_ROLE(Read);
426
24.4k
  APPLY_FOR_ROLE(Write);
427
24.4k
  APPLY_FOR_ROLE(Call);
428
24.4k
  APPLY_FOR_ROLE(Dynamic);
429
24.4k
  APPLY_FOR_ROLE(AddressOf);
430
24.4k
  APPLY_FOR_ROLE(Implicit);
431
24.4k
  APPLY_FOR_ROLE(Undefinition);
432
24.4k
  APPLY_FOR_ROLE(RelationChildOf);
433
24.4k
  APPLY_FOR_ROLE(RelationBaseOf);
434
24.4k
  APPLY_FOR_ROLE(RelationOverrideOf);
435
24.4k
  APPLY_FOR_ROLE(RelationReceivedBy);
436
24.4k
  APPLY_FOR_ROLE(RelationCalledBy);
437
24.4k
  APPLY_FOR_ROLE(RelationExtendedBy);
438
24.4k
  APPLY_FOR_ROLE(RelationAccessorOf);
439
24.4k
  APPLY_FOR_ROLE(RelationContainedBy);
440
24.4k
  APPLY_FOR_ROLE(RelationIBTypeOf);
441
24.4k
  APPLY_FOR_ROLE(RelationSpecializationOf);
442
24.4k
  APPLY_FOR_ROLE(NameReference);
443
444
24.4k
#undef APPLY_FOR_ROLE
445
446
24.4k
  return true;
447
24.4k
}
448
449
void index::applyForEachSymbolRole(SymbolRoleSet Roles,
450
24.4k
                                   llvm::function_ref<void(SymbolRole)> Fn) {
451
26.3k
  applyForEachSymbolRoleInterruptible(Roles, [&](SymbolRole r) -> bool {
452
26.3k
    Fn(r);
453
26.3k
    return true;
454
26.3k
  });
455
24.4k
}
456
457
24.4k
void index::printSymbolRoles(SymbolRoleSet Roles, raw_ostream &OS) {
458
24.4k
  bool VisitedOnce = false;
459
26.3k
  applyForEachSymbolRole(Roles, [&](SymbolRole Role) {
460
26.3k
    if (VisitedOnce)
461
1.90k
      OS << ',';
462
24.4k
    else
463
24.4k
      VisitedOnce = true;
464
26.3k
    switch (Role) {
465
305
    case SymbolRole::Declaration: OS << "Decl"; break;
466
22.2k
    case SymbolRole::Definition: OS << "Def"; break;
467
677
    case SymbolRole::Reference: OS << "Ref"; break;
468
37
    case SymbolRole::Read: OS << "Read"; break;
469
16
    case SymbolRole::Write: OS << "Writ"; break;
470
81
    case SymbolRole::Call: OS << "Call"; break;
471
170
    case SymbolRole::Dynamic: OS << "Dyn"; break;
472
0
    case SymbolRole::AddressOf: OS << "Addr"; break;
473
116
    case SymbolRole::Implicit: OS << "Impl"; break;
474
4
    case SymbolRole::Undefinition: OS << "Undef"; break;
475
946
    case SymbolRole::RelationChildOf: OS << "RelChild"; break;
476
104
    case SymbolRole::RelationBaseOf: OS << "RelBase"; break;
477
2
    case SymbolRole::RelationOverrideOf: OS << "RelOver"; break;
478
68
    case SymbolRole::RelationReceivedBy: OS << "RelRec"; break;
479
150
    case SymbolRole::RelationCalledBy: OS << "RelCall"; break;
480
10
    case SymbolRole::RelationExtendedBy: OS << "RelExt"; break;
481
130
    case SymbolRole::RelationAccessorOf: OS << "RelAcc"; break;
482
1.08k
    case SymbolRole::RelationContainedBy: OS << "RelCont"; break;
483
10
    case SymbolRole::RelationIBTypeOf: OS << "RelIBType"; break;
484
140
    case SymbolRole::RelationSpecializationOf: OS << "RelSpecialization"; break;
485
24
    case SymbolRole::NameReference: OS << "NameReference"; break;
486
26.3k
    }
487
26.3k
  });
488
24.4k
}
489
490
bool index::printSymbolName(const Decl *D, const LangOptions &LO,
491
2.59k
                            raw_ostream &OS) {
492
2.59k
  if (auto *ND = dyn_cast<NamedDecl>(D)) {
493
2.59k
    PrintingPolicy Policy(LO);
494
    // Forward references can have different template argument names. Suppress
495
    // the template argument names in constructors to make their name more
496
    // stable.
497
2.59k
    Policy.SuppressTemplateArgsInCXXConstructors = true;
498
2.59k
    DeclarationName DeclName = ND->getDeclName();
499
2.59k
    if (DeclName.isEmpty())
500
8
      return true;
501
2.58k
    DeclName.print(OS, Policy);
502
2.58k
    return false;
503
2.59k
  } else {
504
0
    return true;
505
0
  }
506
2.59k
}
507
508
23.2k
StringRef index::getSymbolKindString(SymbolKind K) {
509
23.2k
  switch (K) {
510
0
  case SymbolKind::Unknown: return "<unknown>";
511
9
  case SymbolKind::Module: return "module";
512
41
  case SymbolKind::Namespace: return "namespace";
513
10
  case SymbolKind::NamespaceAlias: return "namespace-alias";
514
21.8k
  case SymbolKind::Macro: return "macro";
515
21
  case SymbolKind::Enum: return "enum";
516
186
  case SymbolKind::Struct: return "struct";
517
360
  case SymbolKind::Class: return "class";
518
47
  case SymbolKind::Protocol: return "protocol";
519
8
  case SymbolKind::Extension: return "extension";
520
4
  case SymbolKind::Union: return "union";
521
67
  case SymbolKind::TypeAlias: return "type-alias";
522
99
  case SymbolKind::Function: return "function";
523
69
  case SymbolKind::Variable: return "variable";
524
80
  case SymbolKind::Field: return "field";
525
19
  case SymbolKind::EnumConstant: return "enumerator";
526
204
  case SymbolKind::InstanceMethod: return "instance-method";
527
28
  case SymbolKind::ClassMethod: return "class-method";
528
11
  case SymbolKind::StaticMethod: return "static-method";
529
56
  case SymbolKind::InstanceProperty: return "instance-property";
530
0
  case SymbolKind::ClassProperty: return "class-property";
531
27
  case SymbolKind::StaticProperty: return "static-property";
532
27
  case SymbolKind::Constructor: return "constructor";
533
7
  case SymbolKind::Destructor: return "destructor";
534
0
  case SymbolKind::ConversionFunction: return "conversion-func";
535
25
  case SymbolKind::Parameter: return "param";
536
9
  case SymbolKind::Using: return "using";
537
0
  case SymbolKind::TemplateTypeParm: return "template-type-param";
538
0
  case SymbolKind::TemplateTemplateParm: return "template-template-param";
539
0
  case SymbolKind::NonTypeTemplateParm: return "non-type-template-param";
540
0
  case SymbolKind::Concept:
541
0
    return "concept";
542
23.2k
  }
543
0
  llvm_unreachable("invalid symbol kind");
544
0
}
545
546
113
StringRef index::getSymbolSubKindString(SymbolSubKind K) {
547
113
  switch (K) {
548
0
  case SymbolSubKind::None: return "<none>";
549
4
  case SymbolSubKind::CXXCopyConstructor: return "cxx-copy-ctor";
550
2
  case SymbolSubKind::CXXMoveConstructor: return "cxx-move-ctor";
551
53
  case SymbolSubKind::AccessorGetter: return "acc-get";
552
46
  case SymbolSubKind::AccessorSetter: return "acc-set";
553
2
  case SymbolSubKind::UsingTypename: return "using-typename";
554
6
  case SymbolSubKind::UsingValue: return "using-value";
555
0
  case SymbolSubKind::UsingEnum:
556
0
    return "using-enum";
557
113
  }
558
0
  llvm_unreachable("invalid symbol subkind");
559
0
}
560
561
23.2k
StringRef index::getSymbolLanguageString(SymbolLanguage K) {
562
23.2k
  switch (K) {
563
22.1k
  case SymbolLanguage::C: return "C";
564
427
  case SymbolLanguage::ObjC: return "ObjC";
565
629
  case SymbolLanguage::CXX: return "C++";
566
34
  case SymbolLanguage::Swift: return "Swift";
567
23.2k
  }
568
0
  llvm_unreachable("invalid symbol language kind");
569
0
}
570
571
void index::applyForEachSymbolProperty(SymbolPropertySet Props,
572
321
                                  llvm::function_ref<void(SymbolProperty)> Fn) {
573
321
#define APPLY_FOR_PROPERTY(K)                                                  \
574
2.88k
  if (Props & (SymbolPropertySet)SymbolProperty::K)                            \
575
2.88k
  
Fn(SymbolProperty::K)397
576
577
321
  APPLY_FOR_PROPERTY(Generic);
578
321
  APPLY_FOR_PROPERTY(TemplatePartialSpecialization);
579
321
  APPLY_FOR_PROPERTY(TemplateSpecialization);
580
321
  APPLY_FOR_PROPERTY(UnitTest);
581
321
  APPLY_FOR_PROPERTY(IBAnnotated);
582
321
  APPLY_FOR_PROPERTY(IBOutletCollection);
583
321
  APPLY_FOR_PROPERTY(GKInspectable);
584
321
  APPLY_FOR_PROPERTY(Local);
585
321
  APPLY_FOR_PROPERTY(ProtocolInterface);
586
587
321
#undef APPLY_FOR_PROPERTY
588
321
}
589
590
321
void index::printSymbolProperties(SymbolPropertySet Props, raw_ostream &OS) {
591
321
  bool VisitedOnce = false;
592
397
  applyForEachSymbolProperty(Props, [&](SymbolProperty Prop) {
593
397
    if (VisitedOnce)
594
76
      OS << ',';
595
321
    else
596
321
      VisitedOnce = true;
597
397
    switch (Prop) {
598
253
    case SymbolProperty::Generic: OS << "Gen"; break;
599
16
    case SymbolProperty::TemplatePartialSpecialization: OS << "TPS"; break;
600
55
    case SymbolProperty::TemplateSpecialization: OS << "TS"; break;
601
12
    case SymbolProperty::UnitTest: OS << "test"; break;
602
9
    case SymbolProperty::IBAnnotated: OS << "IB"; break;
603
5
    case SymbolProperty::IBOutletCollection: OS << "IBColl"; break;
604
1
    case SymbolProperty::GKInspectable: OS << "GKI"; break;
605
41
    case SymbolProperty::Local: OS << "local"; break;
606
5
    case SymbolProperty::ProtocolInterface: OS << "protocol"; break;
607
397
    }
608
397
  });
609
321
}