1 //===- IndexDecl.cpp - Indexing declarations ------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "IndexingContext.h" 11 #include "clang/Index/IndexDataConsumer.h" 12 #include "clang/AST/DeclVisitor.h" 13 14 using namespace clang; 15 using namespace index; 16 17 #define TRY_TO(CALL_EXPR) \ 18 do { \ 19 if (!CALL_EXPR) \ 20 return false; \ 21 } while (0) 22 23 namespace { 24 25 class IndexingDeclVisitor : public ConstDeclVisitor<IndexingDeclVisitor, bool> { 26 IndexingContext &IndexCtx; 27 28 public: 29 explicit IndexingDeclVisitor(IndexingContext &indexCtx) 30 : IndexCtx(indexCtx) { } 31 32 bool Handled = true; 33 34 bool VisitDecl(const Decl *D) { 35 Handled = false; 36 return true; 37 } 38 39 /// \brief Returns true if the given method has been defined explicitly by the 40 /// user. 41 static bool hasUserDefined(const ObjCMethodDecl *D, 42 const ObjCImplDecl *Container) { 43 const ObjCMethodDecl *MD = Container->getMethod(D->getSelector(), 44 D->isInstanceMethod()); 45 return MD && !MD->isImplicit() && MD->isThisDeclarationADefinition(); 46 } 47 48 void handleDeclarator(const DeclaratorDecl *D, 49 const NamedDecl *Parent = nullptr) { 50 if (!Parent) Parent = D; 51 52 IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), Parent); 53 IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent); 54 if (IndexCtx.shouldIndexFunctionLocalSymbols()) { 55 // Only index parameters in definitions, parameters in declarations are 56 // not useful. 57 if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) { 58 auto *DC = Parm->getDeclContext(); 59 if (auto *FD = dyn_cast<FunctionDecl>(DC)) { 60 if (FD->isThisDeclarationADefinition()) 61 IndexCtx.handleDecl(Parm); 62 } else if (auto *MD = dyn_cast<ObjCMethodDecl>(DC)) { 63 if (MD->isThisDeclarationADefinition()) 64 IndexCtx.handleDecl(Parm); 65 } else { 66 IndexCtx.handleDecl(Parm); 67 } 68 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 69 if (FD->isThisDeclarationADefinition()) { 70 for (auto PI : FD->parameters()) { 71 IndexCtx.handleDecl(PI); 72 } 73 } 74 } 75 } 76 } 77 78 bool handleObjCMethod(const ObjCMethodDecl *D) { 79 if (!IndexCtx.handleDecl(D, (unsigned)SymbolRole::Dynamic)) 80 return false; 81 IndexCtx.indexTypeSourceInfo(D->getReturnTypeSourceInfo(), D); 82 for (const auto *I : D->parameters()) 83 handleDeclarator(I, D); 84 85 if (D->isThisDeclarationADefinition()) { 86 const Stmt *Body = D->getBody(); 87 if (Body) { 88 IndexCtx.indexBody(Body, D, D); 89 } 90 } 91 return true; 92 } 93 94 bool VisitFunctionDecl(const FunctionDecl *D) { 95 if (D->isDeleted()) 96 return true; 97 98 SymbolRoleSet Roles{}; 99 SmallVector<SymbolRelation, 4> Relations; 100 if (auto *CXXMD = dyn_cast<CXXMethodDecl>(D)) { 101 if (CXXMD->isVirtual()) 102 Roles |= (unsigned)SymbolRole::Dynamic; 103 for (auto I = CXXMD->begin_overridden_methods(), 104 E = CXXMD->end_overridden_methods(); I != E; ++I) { 105 Relations.emplace_back((unsigned)SymbolRole::RelationOverrideOf, *I); 106 } 107 } 108 109 if (!IndexCtx.handleDecl(D, Roles, Relations)) 110 return false; 111 handleDeclarator(D); 112 113 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) { 114 // Constructor initializers. 115 for (const auto *Init : Ctor->inits()) { 116 if (Init->isWritten()) { 117 IndexCtx.indexTypeSourceInfo(Init->getTypeSourceInfo(), D); 118 if (const FieldDecl *Member = Init->getAnyMember()) 119 IndexCtx.handleReference(Member, Init->getMemberLocation(), D, D, 120 (unsigned)SymbolRole::Write); 121 IndexCtx.indexBody(Init->getInit(), D, D); 122 } 123 } 124 } 125 126 if (D->isThisDeclarationADefinition()) { 127 const Stmt *Body = D->getBody(); 128 if (Body) { 129 IndexCtx.indexBody(Body, D, D); 130 } 131 } 132 return true; 133 } 134 135 bool VisitVarDecl(const VarDecl *D) { 136 if (!IndexCtx.handleDecl(D)) 137 return false; 138 handleDeclarator(D); 139 IndexCtx.indexBody(D->getInit(), D); 140 return true; 141 } 142 143 bool VisitFieldDecl(const FieldDecl *D) { 144 if (!IndexCtx.handleDecl(D)) 145 return false; 146 handleDeclarator(D); 147 if (D->isBitField()) 148 IndexCtx.indexBody(D->getBitWidth(), D); 149 else if (D->hasInClassInitializer()) 150 IndexCtx.indexBody(D->getInClassInitializer(), D); 151 return true; 152 } 153 154 bool VisitObjCIvarDecl(const ObjCIvarDecl *D) { 155 if (D->getSynthesize()) { 156 // For synthesized ivars, use the location of the ObjC implementation, 157 // not the location of the property. 158 // Otherwise the header file containing the @interface will have different 159 // indexing contents based on whether the @implementation was present or 160 // not in the translation unit. 161 return IndexCtx.handleDecl(D, 162 cast<Decl>(D->getDeclContext())->getLocation(), 163 (unsigned)SymbolRole::Implicit); 164 } 165 if (!IndexCtx.handleDecl(D)) 166 return false; 167 handleDeclarator(D); 168 return true; 169 } 170 171 bool VisitMSPropertyDecl(const MSPropertyDecl *D) { 172 handleDeclarator(D); 173 return true; 174 } 175 176 bool VisitEnumConstantDecl(const EnumConstantDecl *D) { 177 if (!IndexCtx.handleDecl(D)) 178 return false; 179 IndexCtx.indexBody(D->getInitExpr(), D); 180 return true; 181 } 182 183 bool VisitTypedefNameDecl(const TypedefNameDecl *D) { 184 if (!IndexCtx.handleDecl(D)) 185 return false; 186 IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D); 187 return true; 188 } 189 190 bool VisitTagDecl(const TagDecl *D) { 191 // Non-free standing tags are handled in indexTypeSourceInfo. 192 if (D->isFreeStanding()) { 193 if (D->isThisDeclarationADefinition()) { 194 IndexCtx.indexTagDecl(D); 195 } else { 196 auto *Parent = dyn_cast<NamedDecl>(D->getDeclContext()); 197 return IndexCtx.handleReference(D, D->getLocation(), Parent, 198 D->getLexicalDeclContext(), 199 SymbolRoleSet()); 200 } 201 } 202 return true; 203 } 204 205 bool handleReferencedProtocols(const ObjCProtocolList &ProtList, 206 const ObjCContainerDecl *ContD) { 207 ObjCInterfaceDecl::protocol_loc_iterator LI = ProtList.loc_begin(); 208 for (ObjCInterfaceDecl::protocol_iterator 209 I = ProtList.begin(), E = ProtList.end(); I != E; ++I, ++LI) { 210 SourceLocation Loc = *LI; 211 ObjCProtocolDecl *PD = *I; 212 TRY_TO(IndexCtx.handleReference(PD, Loc, ContD, ContD, 213 SymbolRoleSet(), 214 SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, ContD})); 215 } 216 return true; 217 } 218 219 bool VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { 220 if (D->isThisDeclarationADefinition()) { 221 TRY_TO(IndexCtx.handleDecl(D)); 222 if (auto *SuperD = D->getSuperClass()) { 223 TRY_TO(IndexCtx.handleReference(SuperD, D->getSuperClassLoc(), D, D, 224 SymbolRoleSet(), 225 SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, D})); 226 } 227 TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D)); 228 TRY_TO(IndexCtx.indexDeclContext(D)); 229 } else { 230 return IndexCtx.handleReference(D, D->getLocation(), nullptr, 231 D->getDeclContext(), SymbolRoleSet()); 232 } 233 return true; 234 } 235 236 bool VisitObjCProtocolDecl(const ObjCProtocolDecl *D) { 237 if (D->isThisDeclarationADefinition()) { 238 TRY_TO(IndexCtx.handleDecl(D)); 239 TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D)); 240 TRY_TO(IndexCtx.indexDeclContext(D)); 241 } else { 242 return IndexCtx.handleReference(D, D->getLocation(), nullptr, 243 D->getDeclContext(), SymbolRoleSet()); 244 } 245 return true; 246 } 247 248 bool VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { 249 const ObjCInterfaceDecl *Class = D->getClassInterface(); 250 if (!Class) 251 return true; 252 253 if (Class->isImplicitInterfaceDecl()) 254 IndexCtx.handleDecl(Class); 255 256 if (!IndexCtx.handleDecl(D)) 257 return false; 258 259 // Index the ivars first to make sure the synthesized ivars are indexed 260 // before indexing the methods that can reference them. 261 for (const auto *IvarI : D->ivars()) 262 IndexCtx.indexDecl(IvarI); 263 for (const auto *I : D->decls()) { 264 if (!isa<ObjCIvarDecl>(I)) 265 IndexCtx.indexDecl(I); 266 } 267 268 return true; 269 } 270 271 bool VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { 272 if (!IndexCtx.handleDecl(D)) 273 return false; 274 IndexCtx.indexDeclContext(D); 275 return true; 276 } 277 278 bool VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) { 279 const ObjCCategoryDecl *Cat = D->getCategoryDecl(); 280 if (!Cat) 281 return true; 282 283 if (!IndexCtx.handleDecl(D)) 284 return false; 285 IndexCtx.indexDeclContext(D); 286 return true; 287 } 288 289 bool VisitObjCMethodDecl(const ObjCMethodDecl *D) { 290 // Methods associated with a property, even user-declared ones, are 291 // handled when we handle the property. 292 if (D->isPropertyAccessor()) 293 return true; 294 295 handleObjCMethod(D); 296 return true; 297 } 298 299 bool VisitObjCPropertyDecl(const ObjCPropertyDecl *D) { 300 if (ObjCMethodDecl *MD = D->getGetterMethodDecl()) 301 if (MD->getLexicalDeclContext() == D->getLexicalDeclContext()) 302 handleObjCMethod(MD); 303 if (ObjCMethodDecl *MD = D->getSetterMethodDecl()) 304 if (MD->getLexicalDeclContext() == D->getLexicalDeclContext()) 305 handleObjCMethod(MD); 306 if (!IndexCtx.handleDecl(D)) 307 return false; 308 IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D); 309 return true; 310 } 311 312 bool VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) { 313 ObjCPropertyDecl *PD = D->getPropertyDecl(); 314 if (!IndexCtx.handleReference(PD, D->getLocation(), 315 /*Parent=*/cast<NamedDecl>(D->getDeclContext()), 316 D->getDeclContext(), SymbolRoleSet(), {}, 317 /*RefE=*/nullptr, D)) 318 return false; 319 320 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic) 321 return true; 322 assert(D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize); 323 324 if (ObjCIvarDecl *IvarD = D->getPropertyIvarDecl()) { 325 if (!IvarD->getSynthesize()) 326 IndexCtx.handleReference(IvarD, D->getPropertyIvarDeclLoc(), nullptr, 327 D->getDeclContext(), SymbolRoleSet()); 328 } 329 330 auto *ImplD = cast<ObjCImplDecl>(D->getDeclContext()); 331 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) { 332 if (MD->isPropertyAccessor() && 333 !hasUserDefined(MD, ImplD)) 334 IndexCtx.handleDecl(MD, D->getLocation(), SymbolRoleSet(), {}, ImplD); 335 } 336 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) { 337 if (MD->isPropertyAccessor() && 338 !hasUserDefined(MD, ImplD)) 339 IndexCtx.handleDecl(MD, D->getLocation(), SymbolRoleSet(), {}, ImplD); 340 } 341 return true; 342 } 343 344 bool VisitNamespaceDecl(const NamespaceDecl *D) { 345 if (!IndexCtx.handleDecl(D)) 346 return false; 347 IndexCtx.indexDeclContext(D); 348 return true; 349 } 350 351 bool VisitUsingDecl(const UsingDecl *D) { 352 const DeclContext *DC = D->getDeclContext()->getRedeclContext(); 353 const NamedDecl *Parent = dyn_cast<NamedDecl>(DC); 354 355 IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent, 356 D->getLexicalDeclContext()); 357 for (const auto *I : D->shadows()) 358 IndexCtx.handleReference(I->getUnderlyingDecl(), D->getLocation(), Parent, 359 D->getLexicalDeclContext(), SymbolRoleSet()); 360 return true; 361 } 362 363 bool VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) { 364 const DeclContext *DC = D->getDeclContext()->getRedeclContext(); 365 const NamedDecl *Parent = dyn_cast<NamedDecl>(DC); 366 367 IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent, 368 D->getLexicalDeclContext()); 369 return IndexCtx.handleReference(D->getNominatedNamespaceAsWritten(), 370 D->getLocation(), Parent, 371 D->getLexicalDeclContext(), 372 SymbolRoleSet()); 373 } 374 375 bool VisitClassTemplateSpecializationDecl(const 376 ClassTemplateSpecializationDecl *D) { 377 // FIXME: Notify subsequent callbacks if info comes from implicit 378 // instantiation. 379 if (D->isThisDeclarationADefinition()) 380 IndexCtx.indexTagDecl(D); 381 return true; 382 } 383 384 bool VisitTemplateDecl(const TemplateDecl *D) { 385 // FIXME: Template parameters. 386 return Visit(D->getTemplatedDecl()); 387 } 388 389 bool VisitFriendDecl(const FriendDecl *D) { 390 if (auto ND = D->getFriendDecl()) { 391 // FIXME: Ignore a class template in a dependent context, these are not 392 // linked properly with their redeclarations, ending up with duplicate 393 // USRs. 394 // See comment "Friend templates are visible in fairly strange ways." in 395 // SemaTemplate.cpp which precedes code that prevents the friend template 396 // from becoming visible from the enclosing context. 397 if (isa<ClassTemplateDecl>(ND) && D->getDeclContext()->isDependentContext()) 398 return true; 399 return Visit(ND); 400 } 401 if (auto Ty = D->getFriendType()) { 402 IndexCtx.indexTypeSourceInfo(Ty, cast<NamedDecl>(D->getDeclContext())); 403 } 404 return true; 405 } 406 407 bool VisitImportDecl(const ImportDecl *D) { 408 return IndexCtx.importedModule(D); 409 } 410 }; 411 412 } // anonymous namespace 413 414 bool IndexingContext::indexDecl(const Decl *D) { 415 if (D->isImplicit() && shouldIgnoreIfImplicit(D)) 416 return true; 417 418 if (isTemplateImplicitInstantiation(D)) 419 return true; 420 421 IndexingDeclVisitor Visitor(*this); 422 bool ShouldContinue = Visitor.Visit(D); 423 if (!ShouldContinue) 424 return false; 425 426 if (!Visitor.Handled && isa<DeclContext>(D)) 427 return indexDeclContext(cast<DeclContext>(D)); 428 429 return true; 430 } 431 432 bool IndexingContext::indexDeclContext(const DeclContext *DC) { 433 for (const auto *I : DC->decls()) 434 if (!indexDecl(I)) 435 return false; 436 return true; 437 } 438 439 bool IndexingContext::indexTopLevelDecl(const Decl *D) { 440 if (D->getLocation().isInvalid()) 441 return true; 442 443 if (isa<ObjCMethodDecl>(D)) 444 return true; // Wait for the objc container. 445 446 return indexDecl(D); 447 } 448 449 bool IndexingContext::indexDeclGroupRef(DeclGroupRef DG) { 450 for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I) 451 if (!indexTopLevelDecl(*I)) 452 return false; 453 return true; 454 } 455
