• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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:
IndexingDeclVisitor(IndexingContext & indexCtx)29   explicit IndexingDeclVisitor(IndexingContext &indexCtx)
30     : IndexCtx(indexCtx) { }
31 
32   bool Handled = true;
33 
VisitDecl(const Decl * D)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.
hasUserDefined(const ObjCMethodDecl * D,const ObjCImplDecl * Container)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 
handleDeclarator(const DeclaratorDecl * D,const NamedDecl * Parent=nullptr)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 
handleObjCMethod(const ObjCMethodDecl * D)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 
VisitFunctionDecl(const FunctionDecl * D)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 
VisitVarDecl(const VarDecl * D)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 
VisitFieldDecl(const FieldDecl * D)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 
VisitObjCIvarDecl(const ObjCIvarDecl * D)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 
VisitMSPropertyDecl(const MSPropertyDecl * D)171   bool VisitMSPropertyDecl(const MSPropertyDecl *D) {
172     handleDeclarator(D);
173     return true;
174   }
175 
VisitEnumConstantDecl(const EnumConstantDecl * D)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 
VisitTypedefNameDecl(const TypedefNameDecl * D)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 
VisitTagDecl(const TagDecl * D)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 
handleReferencedProtocols(const ObjCProtocolList & ProtList,const ObjCContainerDecl * ContD)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 
VisitObjCInterfaceDecl(const ObjCInterfaceDecl * D)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 
VisitObjCProtocolDecl(const ObjCProtocolDecl * D)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 
VisitObjCImplementationDecl(const ObjCImplementationDecl * D)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 
VisitObjCCategoryDecl(const ObjCCategoryDecl * D)271   bool VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
272     if (!IndexCtx.handleDecl(D))
273       return false;
274     IndexCtx.indexDeclContext(D);
275     return true;
276   }
277 
VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl * D)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 
VisitObjCMethodDecl(const ObjCMethodDecl * D)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 
VisitObjCPropertyDecl(const ObjCPropertyDecl * D)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 
VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl * D)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 
VisitNamespaceDecl(const NamespaceDecl * D)344   bool VisitNamespaceDecl(const NamespaceDecl *D) {
345     if (!IndexCtx.handleDecl(D))
346       return false;
347     IndexCtx.indexDeclContext(D);
348     return true;
349   }
350 
VisitUsingDecl(const UsingDecl * D)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 
VisitUsingDirectiveDecl(const UsingDirectiveDecl * D)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 
VisitClassTemplateSpecializationDecl(const ClassTemplateSpecializationDecl * D)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 
VisitTemplateDecl(const TemplateDecl * D)384   bool VisitTemplateDecl(const TemplateDecl *D) {
385     // FIXME: Template parameters.
386     return Visit(D->getTemplatedDecl());
387   }
388 
VisitFriendDecl(const FriendDecl * D)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 
VisitImportDecl(const ImportDecl * D)407   bool VisitImportDecl(const ImportDecl *D) {
408     return IndexCtx.importedModule(D);
409   }
410 };
411 
412 } // anonymous namespace
413 
indexDecl(const Decl * D)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 
indexDeclContext(const DeclContext * DC)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 
indexTopLevelDecl(const Decl * D)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 
indexDeclGroupRef(DeclGroupRef DG)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