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                         const ObjCPropertyDecl *AssociatedProp = nullptr) {
80     SmallVector<SymbolRelation, 4> Relations;
81     SmallVector<const ObjCMethodDecl*, 4> Overriden;
82 
83     D->getOverriddenMethods(Overriden);
84     for(auto overridden: Overriden) {
85       Relations.emplace_back((unsigned) SymbolRole::RelationOverrideOf,
86                              overridden);
87     }
88     if (AssociatedProp)
89       Relations.emplace_back((unsigned)SymbolRole::RelationAccessorOf,
90                              AssociatedProp);
91 
92     if (!IndexCtx.handleDecl(D, (unsigned)SymbolRole::Dynamic, Relations))
93       return false;
94     IndexCtx.indexTypeSourceInfo(D->getReturnTypeSourceInfo(), D);
95     for (const auto *I : D->parameters())
96       handleDeclarator(I, D);
97 
98     if (D->isThisDeclarationADefinition()) {
99       const Stmt *Body = D->getBody();
100       if (Body) {
101         IndexCtx.indexBody(Body, D, D);
102       }
103     }
104     return true;
105   }
106 
107   bool VisitFunctionDecl(const FunctionDecl *D) {
108     if (D->isDeleted())
109       return true;
110 
111     SymbolRoleSet Roles{};
112     SmallVector<SymbolRelation, 4> Relations;
113     if (auto *CXXMD = dyn_cast<CXXMethodDecl>(D)) {
114       if (CXXMD->isVirtual())
115         Roles |= (unsigned)SymbolRole::Dynamic;
116       for (auto I = CXXMD->begin_overridden_methods(),
117            E = CXXMD->end_overridden_methods(); I != E; ++I) {
118         Relations.emplace_back((unsigned)SymbolRole::RelationOverrideOf, *I);
119       }
120     }
121 
122     if (!IndexCtx.handleDecl(D, Roles, Relations))
123       return false;
124     handleDeclarator(D);
125 
126     if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
127       // Constructor initializers.
128       for (const auto *Init : Ctor->inits()) {
129         if (Init->isWritten()) {
130           IndexCtx.indexTypeSourceInfo(Init->getTypeSourceInfo(), D);
131           if (const FieldDecl *Member = Init->getAnyMember())
132             IndexCtx.handleReference(Member, Init->getMemberLocation(), D, D,
133                                      (unsigned)SymbolRole::Write);
134           IndexCtx.indexBody(Init->getInit(), D, D);
135         }
136       }
137     }
138 
139     if (D->isThisDeclarationADefinition()) {
140       const Stmt *Body = D->getBody();
141       if (Body) {
142         IndexCtx.indexBody(Body, D, D);
143       }
144     }
145     return true;
146   }
147 
148   bool VisitVarDecl(const VarDecl *D) {
149     if (!IndexCtx.handleDecl(D))
150       return false;
151     handleDeclarator(D);
152     IndexCtx.indexBody(D->getInit(), D);
153     return true;
154   }
155 
156   bool VisitFieldDecl(const FieldDecl *D) {
157     if (!IndexCtx.handleDecl(D))
158       return false;
159     handleDeclarator(D);
160     if (D->isBitField())
161       IndexCtx.indexBody(D->getBitWidth(), D);
162     else if (D->hasInClassInitializer())
163       IndexCtx.indexBody(D->getInClassInitializer(), D);
164     return true;
165   }
166 
167   bool VisitObjCIvarDecl(const ObjCIvarDecl *D) {
168     if (D->getSynthesize()) {
169       // For synthesized ivars, use the location of the ObjC implementation,
170       // not the location of the property.
171       // Otherwise the header file containing the @interface will have different
172       // indexing contents based on whether the @implementation was present or
173       // not in the translation unit.
174       return IndexCtx.handleDecl(D,
175                                  cast<Decl>(D->getDeclContext())->getLocation(),
176                                  (unsigned)SymbolRole::Implicit);
177     }
178     if (!IndexCtx.handleDecl(D))
179       return false;
180     handleDeclarator(D);
181     return true;
182   }
183 
184   bool VisitMSPropertyDecl(const MSPropertyDecl *D) {
185     handleDeclarator(D);
186     return true;
187   }
188 
189   bool VisitEnumConstantDecl(const EnumConstantDecl *D) {
190     if (!IndexCtx.handleDecl(D))
191       return false;
192     IndexCtx.indexBody(D->getInitExpr(), D);
193     return true;
194   }
195 
196   bool VisitTypedefNameDecl(const TypedefNameDecl *D) {
197     if (!IndexCtx.handleDecl(D))
198       return false;
199     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
200     return true;
201   }
202 
203   bool VisitTagDecl(const TagDecl *D) {
204     // Non-free standing tags are handled in indexTypeSourceInfo.
205     if (D->isFreeStanding()) {
206       if (D->isThisDeclarationADefinition()) {
207         IndexCtx.indexTagDecl(D);
208       } else {
209         auto *Parent = dyn_cast<NamedDecl>(D->getDeclContext());
210         return IndexCtx.handleReference(D, D->getLocation(), Parent,
211                                         D->getLexicalDeclContext(),
212                                         SymbolRoleSet());
213       }
214     }
215     return true;
216   }
217 
218   bool handleReferencedProtocols(const ObjCProtocolList &ProtList,
219                                  const ObjCContainerDecl *ContD) {
220     ObjCInterfaceDecl::protocol_loc_iterator LI = ProtList.loc_begin();
221     for (ObjCInterfaceDecl::protocol_iterator
222          I = ProtList.begin(), E = ProtList.end(); I != E; ++I, ++LI) {
223       SourceLocation Loc = *LI;
224       ObjCProtocolDecl *PD = *I;
225       TRY_TO(IndexCtx.handleReference(PD, Loc, ContD, ContD,
226           SymbolRoleSet(),
227           SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, ContD}));
228     }
229     return true;
230   }
231 
232   bool VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
233     if (D->isThisDeclarationADefinition()) {
234       TRY_TO(IndexCtx.handleDecl(D));
235       if (auto *SuperD = D->getSuperClass()) {
236         TRY_TO(IndexCtx.handleReference(SuperD, D->getSuperClassLoc(), D, D,
237             SymbolRoleSet(),
238             SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, D}));
239       }
240       TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D));
241       TRY_TO(IndexCtx.indexDeclContext(D));
242     } else {
243       return IndexCtx.handleReference(D, D->getLocation(), nullptr,
244                                       D->getDeclContext(), SymbolRoleSet());
245     }
246     return true;
247   }
248 
249   bool VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
250     if (D->isThisDeclarationADefinition()) {
251       TRY_TO(IndexCtx.handleDecl(D));
252       TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D));
253       TRY_TO(IndexCtx.indexDeclContext(D));
254     } else {
255       return IndexCtx.handleReference(D, D->getLocation(), nullptr,
256                                       D->getDeclContext(), SymbolRoleSet());
257     }
258     return true;
259   }
260 
261   bool VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
262     const ObjCInterfaceDecl *Class = D->getClassInterface();
263     if (!Class)
264       return true;
265 
266     if (Class->isImplicitInterfaceDecl())
267       IndexCtx.handleDecl(Class);
268 
269     if (!IndexCtx.handleDecl(D))
270       return false;
271 
272     // Index the ivars first to make sure the synthesized ivars are indexed
273     // before indexing the methods that can reference them.
274     for (const auto *IvarI : D->ivars())
275       IndexCtx.indexDecl(IvarI);
276     for (const auto *I : D->decls()) {
277       if (!isa<ObjCIvarDecl>(I))
278         IndexCtx.indexDecl(I);
279     }
280 
281     return true;
282   }
283 
284   bool VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
285     const ObjCInterfaceDecl *C = D->getClassInterface();
286     if (C)
287       TRY_TO(IndexCtx.handleReference(C, D->getLocation(), D, D,
288                                   SymbolRoleSet(), SymbolRelation{
289                                     (unsigned)SymbolRole::RelationExtendedBy, D
290                                   }));
291     SourceLocation CategoryLoc = D->getCategoryNameLoc();
292     if (!CategoryLoc.isValid())
293       CategoryLoc = D->getLocation();
294     TRY_TO(IndexCtx.handleDecl(D, CategoryLoc));
295     TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D));
296     TRY_TO(IndexCtx.indexDeclContext(D));
297     return true;
298   }
299 
300   bool VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
301     const ObjCCategoryDecl *Cat = D->getCategoryDecl();
302     if (!Cat)
303       return true;
304     const ObjCInterfaceDecl *C = D->getClassInterface();
305     if (C)
306       TRY_TO(IndexCtx.handleReference(C, D->getLocation(), D, D,
307                                       SymbolRoleSet()));
308     SourceLocation CategoryLoc = D->getCategoryNameLoc();
309     if (!CategoryLoc.isValid())
310       CategoryLoc = D->getLocation();
311     if (!IndexCtx.handleDecl(D, CategoryLoc))
312       return false;
313     IndexCtx.indexDeclContext(D);
314     return true;
315   }
316 
317   bool VisitObjCMethodDecl(const ObjCMethodDecl *D) {
318     // Methods associated with a property, even user-declared ones, are
319     // handled when we handle the property.
320     if (D->isPropertyAccessor())
321       return true;
322 
323     handleObjCMethod(D);
324     return true;
325   }
326 
327   bool VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
328     if (ObjCMethodDecl *MD = D->getGetterMethodDecl())
329       if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
330         handleObjCMethod(MD, D);
331     if (ObjCMethodDecl *MD = D->getSetterMethodDecl())
332       if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
333         handleObjCMethod(MD, D);
334     if (!IndexCtx.handleDecl(D))
335       return false;
336     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
337     return true;
338   }
339 
340   bool VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
341     ObjCPropertyDecl *PD = D->getPropertyDecl();
342     if (!IndexCtx.handleReference(PD, D->getLocation(),
343                              /*Parent=*/cast<NamedDecl>(D->getDeclContext()),
344                              D->getDeclContext(), SymbolRoleSet(), {},
345                              /*RefE=*/nullptr, D))
346       return false;
347 
348     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
349       return true;
350     assert(D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize);
351 
352     if (ObjCIvarDecl *IvarD = D->getPropertyIvarDecl()) {
353       if (!IvarD->getSynthesize())
354         IndexCtx.handleReference(IvarD, D->getPropertyIvarDeclLoc(), nullptr,
355                                  D->getDeclContext(), SymbolRoleSet());
356     }
357 
358     auto *ImplD = cast<ObjCImplDecl>(D->getDeclContext());
359     if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) {
360       if (MD->isPropertyAccessor() &&
361           !hasUserDefined(MD, ImplD))
362         IndexCtx.handleDecl(MD, D->getLocation(), SymbolRoleSet(), {}, ImplD);
363     }
364     if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) {
365       if (MD->isPropertyAccessor() &&
366           !hasUserDefined(MD, ImplD))
367         IndexCtx.handleDecl(MD, D->getLocation(), SymbolRoleSet(), {}, ImplD);
368     }
369     return true;
370   }
371 
372   bool VisitNamespaceDecl(const NamespaceDecl *D) {
373     if (!IndexCtx.handleDecl(D))
374       return false;
375     IndexCtx.indexDeclContext(D);
376     return true;
377   }
378 
379   bool VisitUsingDecl(const UsingDecl *D) {
380     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
381     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
382 
383     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
384                                          D->getLexicalDeclContext());
385     for (const auto *I : D->shadows())
386       IndexCtx.handleReference(I->getUnderlyingDecl(), D->getLocation(), Parent,
387                                D->getLexicalDeclContext(), SymbolRoleSet());
388     return true;
389   }
390 
391   bool VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
392     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
393     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
394 
395     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
396                                          D->getLexicalDeclContext());
397     return IndexCtx.handleReference(D->getNominatedNamespaceAsWritten(),
398                                     D->getLocation(), Parent,
399                                     D->getLexicalDeclContext(),
400                                     SymbolRoleSet());
401   }
402 
403   bool VisitClassTemplateSpecializationDecl(const
404                                            ClassTemplateSpecializationDecl *D) {
405     // FIXME: Notify subsequent callbacks if info comes from implicit
406     // instantiation.
407     if (D->isThisDeclarationADefinition())
408       IndexCtx.indexTagDecl(D);
409     return true;
410   }
411 
412   bool VisitTemplateDecl(const TemplateDecl *D) {
413     // FIXME: Template parameters.
414     return Visit(D->getTemplatedDecl());
415   }
416 
417   bool VisitFriendDecl(const FriendDecl *D) {
418     if (auto ND = D->getFriendDecl()) {
419       // FIXME: Ignore a class template in a dependent context, these are not
420       // linked properly with their redeclarations, ending up with duplicate
421       // USRs.
422       // See comment "Friend templates are visible in fairly strange ways." in
423       // SemaTemplate.cpp which precedes code that prevents the friend template
424       // from becoming visible from the enclosing context.
425       if (isa<ClassTemplateDecl>(ND) && D->getDeclContext()->isDependentContext())
426         return true;
427       return Visit(ND);
428     }
429     if (auto Ty = D->getFriendType()) {
430       IndexCtx.indexTypeSourceInfo(Ty, cast<NamedDecl>(D->getDeclContext()));
431     }
432     return true;
433   }
434 
435   bool VisitImportDecl(const ImportDecl *D) {
436     return IndexCtx.importedModule(D);
437   }
438 };
439 
440 } // anonymous namespace
441 
442 bool IndexingContext::indexDecl(const Decl *D) {
443   if (D->isImplicit() && shouldIgnoreIfImplicit(D))
444     return true;
445 
446   if (isTemplateImplicitInstantiation(D))
447     return true;
448 
449   IndexingDeclVisitor Visitor(*this);
450   bool ShouldContinue = Visitor.Visit(D);
451   if (!ShouldContinue)
452     return false;
453 
454   if (!Visitor.Handled && isa<DeclContext>(D))
455     return indexDeclContext(cast<DeclContext>(D));
456 
457   return true;
458 }
459 
460 bool IndexingContext::indexDeclContext(const DeclContext *DC) {
461   for (const auto *I : DC->decls())
462     if (!indexDecl(I))
463       return false;
464   return true;
465 }
466 
467 bool IndexingContext::indexTopLevelDecl(const Decl *D) {
468   if (D->getLocation().isInvalid())
469     return true;
470 
471   if (isa<ObjCMethodDecl>(D))
472     return true; // Wait for the objc container.
473 
474   return indexDecl(D);
475 }
476 
477 bool IndexingContext::indexDeclGroupRef(DeclGroupRef DG) {
478   for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
479     if (!indexTopLevelDecl(*I))
480       return false;
481   return true;
482 }
483