• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- CIndexHigh.cpp - Higher level API functions ------------------------===//
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 
12 #include "clang/AST/DeclVisitor.h"
13 
14 using namespace clang;
15 using namespace cxindex;
16 
17 namespace {
18 
19 class IndexingDeclVisitor : public DeclVisitor<IndexingDeclVisitor, bool> {
20   IndexingContext &IndexCtx;
21 
22 public:
IndexingDeclVisitor(IndexingContext & indexCtx)23   explicit IndexingDeclVisitor(IndexingContext &indexCtx)
24     : IndexCtx(indexCtx) { }
25 
handleDeclarator(DeclaratorDecl * D,const NamedDecl * Parent=0)26   void handleDeclarator(DeclaratorDecl *D, const NamedDecl *Parent = 0) {
27     if (!Parent) Parent = D;
28 
29     if (!IndexCtx.shouldIndexFunctionLocalSymbols()) {
30       IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), Parent);
31       IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent);
32     } else {
33       if (ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
34         IndexCtx.handleVar(Parm);
35       } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
36         for (FunctionDecl::param_iterator
37                PI = FD->param_begin(), PE = FD->param_end(); PI != PE; ++PI) {
38           IndexCtx.handleVar(*PI);
39         }
40       }
41     }
42   }
43 
handleObjCMethod(ObjCMethodDecl * D)44   void handleObjCMethod(ObjCMethodDecl *D) {
45     IndexCtx.handleObjCMethod(D);
46     if (D->isImplicit())
47       return;
48 
49     IndexCtx.indexTypeSourceInfo(D->getResultTypeSourceInfo(), D);
50     for (ObjCMethodDecl::param_iterator
51            I = D->param_begin(), E = D->param_end(); I != E; ++I)
52       handleDeclarator(*I, D);
53 
54     if (D->isThisDeclarationADefinition()) {
55       const Stmt *Body = D->getBody();
56       if (Body) {
57         IndexCtx.indexBody(Body, D, D);
58       }
59     }
60   }
61 
VisitFunctionDecl(FunctionDecl * D)62   bool VisitFunctionDecl(FunctionDecl *D) {
63     IndexCtx.handleFunction(D);
64     handleDeclarator(D);
65 
66     if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
67       // Constructor initializers.
68       for (CXXConstructorDecl::init_iterator I = Ctor->init_begin(),
69                                              E = Ctor->init_end();
70            I != E; ++I) {
71         CXXCtorInitializer *Init = *I;
72         if (Init->isWritten()) {
73           IndexCtx.indexTypeSourceInfo(Init->getTypeSourceInfo(), D);
74           if (const FieldDecl *Member = Init->getAnyMember())
75             IndexCtx.handleReference(Member, Init->getMemberLocation(), D, D);
76           IndexCtx.indexBody(Init->getInit(), D, D);
77         }
78       }
79     }
80 
81     if (D->isThisDeclarationADefinition()) {
82       const Stmt *Body = D->getBody();
83       if (Body) {
84         IndexCtx.indexBody(Body, D, D);
85       }
86     }
87     return true;
88   }
89 
VisitVarDecl(VarDecl * D)90   bool VisitVarDecl(VarDecl *D) {
91     IndexCtx.handleVar(D);
92     handleDeclarator(D);
93     IndexCtx.indexBody(D->getInit(), D);
94     return true;
95   }
96 
VisitFieldDecl(FieldDecl * D)97   bool VisitFieldDecl(FieldDecl *D) {
98     IndexCtx.handleField(D);
99     handleDeclarator(D);
100     if (D->isBitField())
101       IndexCtx.indexBody(D->getBitWidth(), D);
102     else if (D->hasInClassInitializer())
103       IndexCtx.indexBody(D->getInClassInitializer(), D);
104     return true;
105   }
106 
VisitEnumConstantDecl(EnumConstantDecl * D)107   bool VisitEnumConstantDecl(EnumConstantDecl *D) {
108     IndexCtx.handleEnumerator(D);
109     IndexCtx.indexBody(D->getInitExpr(), D);
110     return true;
111   }
112 
VisitTypedefNameDecl(TypedefNameDecl * D)113   bool VisitTypedefNameDecl(TypedefNameDecl *D) {
114     IndexCtx.handleTypedefName(D);
115     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
116     return true;
117   }
118 
VisitTagDecl(TagDecl * D)119   bool VisitTagDecl(TagDecl *D) {
120     // Non-free standing tags are handled in indexTypeSourceInfo.
121     if (D->isFreeStanding())
122       IndexCtx.indexTagDecl(D);
123     return true;
124   }
125 
VisitObjCInterfaceDecl(ObjCInterfaceDecl * D)126   bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
127     IndexCtx.handleObjCInterface(D);
128 
129     if (D->isThisDeclarationADefinition()) {
130       IndexCtx.indexTUDeclsInObjCContainer();
131       IndexCtx.indexDeclContext(D);
132     }
133     return true;
134   }
135 
VisitObjCProtocolDecl(ObjCProtocolDecl * D)136   bool VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
137     IndexCtx.handleObjCProtocol(D);
138 
139     if (D->isThisDeclarationADefinition()) {
140       IndexCtx.indexTUDeclsInObjCContainer();
141       IndexCtx.indexDeclContext(D);
142     }
143     return true;
144   }
145 
VisitObjCImplementationDecl(ObjCImplementationDecl * D)146   bool VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
147     const ObjCInterfaceDecl *Class = D->getClassInterface();
148     if (!Class)
149       return true;
150 
151     if (Class->isImplicitInterfaceDecl())
152       IndexCtx.handleObjCInterface(Class);
153 
154     IndexCtx.handleObjCImplementation(D);
155 
156     IndexCtx.indexTUDeclsInObjCContainer();
157 
158     // Index the ivars first to make sure the synthesized ivars are indexed
159     // before indexing the methods that can reference them.
160     for (ObjCImplementationDecl::ivar_iterator
161            IvarI = D->ivar_begin(),
162            IvarE = D->ivar_end(); IvarI != IvarE; ++IvarI) {
163       IndexCtx.indexDecl(*IvarI);
164     }
165     for (DeclContext::decl_iterator
166            I = D->decls_begin(), E = D->decls_end(); I != E; ++I) {
167       if (!isa<ObjCIvarDecl>(*I))
168         IndexCtx.indexDecl(*I);
169     }
170 
171     return true;
172   }
173 
VisitObjCCategoryDecl(ObjCCategoryDecl * D)174   bool VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
175     IndexCtx.handleObjCCategory(D);
176 
177     IndexCtx.indexTUDeclsInObjCContainer();
178     IndexCtx.indexDeclContext(D);
179     return true;
180   }
181 
VisitObjCCategoryImplDecl(ObjCCategoryImplDecl * D)182   bool VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
183     const ObjCCategoryDecl *Cat = D->getCategoryDecl();
184     if (!Cat)
185       return true;
186 
187     IndexCtx.handleObjCCategoryImpl(D);
188 
189     IndexCtx.indexTUDeclsInObjCContainer();
190     IndexCtx.indexDeclContext(D);
191     return true;
192   }
193 
VisitObjCMethodDecl(ObjCMethodDecl * D)194   bool VisitObjCMethodDecl(ObjCMethodDecl *D) {
195     // Methods associated with a property, even user-declared ones, are
196     // handled when we handle the property.
197     if (D->isSynthesized())
198       return true;
199 
200     handleObjCMethod(D);
201     return true;
202   }
203 
VisitObjCPropertyDecl(ObjCPropertyDecl * D)204   bool VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
205     if (ObjCMethodDecl *MD = D->getGetterMethodDecl())
206       if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
207         handleObjCMethod(MD);
208     if (ObjCMethodDecl *MD = D->getSetterMethodDecl())
209       if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
210         handleObjCMethod(MD);
211     IndexCtx.handleObjCProperty(D);
212     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
213     return true;
214   }
215 
VisitObjCPropertyImplDecl(ObjCPropertyImplDecl * D)216   bool VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
217     ObjCPropertyDecl *PD = D->getPropertyDecl();
218     IndexCtx.handleSynthesizedObjCProperty(D);
219 
220     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
221       return true;
222     assert(D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize);
223 
224     if (ObjCIvarDecl *IvarD = D->getPropertyIvarDecl()) {
225       if (!IvarD->getSynthesize())
226         IndexCtx.handleReference(IvarD, D->getPropertyIvarDeclLoc(), 0,
227                                  D->getDeclContext());
228     }
229 
230     if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) {
231       if (MD->isSynthesized())
232         IndexCtx.handleSynthesizedObjCMethod(MD, D->getLocation(),
233                                              D->getLexicalDeclContext());
234     }
235     if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) {
236       if (MD->isSynthesized())
237         IndexCtx.handleSynthesizedObjCMethod(MD, D->getLocation(),
238                                              D->getLexicalDeclContext());
239     }
240     return true;
241   }
242 
VisitNamespaceDecl(NamespaceDecl * D)243   bool VisitNamespaceDecl(NamespaceDecl *D) {
244     IndexCtx.handleNamespace(D);
245     IndexCtx.indexDeclContext(D);
246     return true;
247   }
248 
VisitUsingDecl(UsingDecl * D)249   bool VisitUsingDecl(UsingDecl *D) {
250     // FIXME: Parent for the following is CXIdxEntity_Unexposed with no USR,
251     // we should do better.
252 
253     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
254     for (UsingDecl::shadow_iterator
255            I = D->shadow_begin(), E = D->shadow_end(); I != E; ++I) {
256       IndexCtx.handleReference((*I)->getUnderlyingDecl(), D->getLocation(),
257                                D, D->getLexicalDeclContext());
258     }
259     return true;
260   }
261 
VisitUsingDirectiveDecl(UsingDirectiveDecl * D)262   bool VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
263     // FIXME: Parent for the following is CXIdxEntity_Unexposed with no USR,
264     // we should do better.
265 
266     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
267     IndexCtx.handleReference(D->getNominatedNamespaceAsWritten(),
268                              D->getLocation(), D, D->getLexicalDeclContext());
269     return true;
270   }
271 
VisitClassTemplateDecl(ClassTemplateDecl * D)272   bool VisitClassTemplateDecl(ClassTemplateDecl *D) {
273     IndexCtx.handleClassTemplate(D);
274     if (D->isThisDeclarationADefinition())
275       IndexCtx.indexDeclContext(D->getTemplatedDecl());
276     return true;
277   }
278 
VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl * D)279   bool VisitClassTemplateSpecializationDecl(
280                                            ClassTemplateSpecializationDecl *D) {
281     // FIXME: Notify subsequent callbacks if info comes from implicit
282     // instantiation.
283     if (D->isThisDeclarationADefinition() &&
284         (IndexCtx.shouldIndexImplicitTemplateInsts() ||
285          !IndexCtx.isTemplateImplicitInstantiation(D)))
286       IndexCtx.indexTagDecl(D);
287     return true;
288   }
289 
VisitFunctionTemplateDecl(FunctionTemplateDecl * D)290   bool VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
291     IndexCtx.handleFunctionTemplate(D);
292     FunctionDecl *FD = D->getTemplatedDecl();
293     handleDeclarator(FD, D);
294     if (FD->isThisDeclarationADefinition()) {
295       const Stmt *Body = FD->getBody();
296       if (Body) {
297         IndexCtx.indexBody(Body, D, FD);
298       }
299     }
300     return true;
301   }
302 
VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl * D)303   bool VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
304     IndexCtx.handleTypeAliasTemplate(D);
305     IndexCtx.indexTypeSourceInfo(D->getTemplatedDecl()->getTypeSourceInfo(), D);
306     return true;
307   }
308 };
309 
310 } // anonymous namespace
311 
indexDecl(const Decl * D)312 void IndexingContext::indexDecl(const Decl *D) {
313   if (D->isImplicit() && shouldIgnoreIfImplicit(D))
314     return;
315 
316   bool Handled = IndexingDeclVisitor(*this).Visit(const_cast<Decl*>(D));
317   if (!Handled && isa<DeclContext>(D))
318     indexDeclContext(cast<DeclContext>(D));
319 }
320 
indexDeclContext(const DeclContext * DC)321 void IndexingContext::indexDeclContext(const DeclContext *DC) {
322   for (DeclContext::decl_iterator
323          I = DC->decls_begin(), E = DC->decls_end(); I != E; ++I) {
324     indexDecl(*I);
325   }
326 }
327 
indexTopLevelDecl(Decl * D)328 void IndexingContext::indexTopLevelDecl(Decl *D) {
329   if (isNotFromSourceFile(D->getLocation()))
330     return;
331 
332   if (isa<ObjCMethodDecl>(D))
333     return; // Wait for the objc container.
334 
335   indexDecl(D);
336 }
337 
indexDeclGroupRef(DeclGroupRef DG)338 void IndexingContext::indexDeclGroupRef(DeclGroupRef DG) {
339   for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
340     indexTopLevelDecl(*I);
341 }
342 
indexTUDeclsInObjCContainer()343 void IndexingContext::indexTUDeclsInObjCContainer() {
344   while (!TUDeclsInObjCContainer.empty()) {
345     DeclGroupRef DG = TUDeclsInObjCContainer.front();
346     TUDeclsInObjCContainer.pop_front();
347     indexDeclGroupRef(DG);
348   }
349 }
350