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