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