/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 | } |