IndexDecl.cpp revision f911242f43ae1b0a85c323631fe817df95c9cbe9 
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
14using namespace clang;
15using namespace cxindex;
16
17namespace {
18
19class IndexingDeclVisitor : public DeclVisitor<IndexingDeclVisitor, bool> {
20  IndexingContext &IndexCtx;
21
22public:
23  explicit IndexingDeclVisitor(IndexingContext &indexCtx)
24    : IndexCtx(indexCtx) { }
25
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
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
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
90  bool VisitVarDecl(VarDecl *D) {
91    IndexCtx.handleVar(D);
92    handleDeclarator(D);
93    IndexCtx.indexBody(D->getInit(), D);
94    return true;
95  }
96
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
107  bool VisitEnumConstantDecl(EnumConstantDecl *D) {
108    IndexCtx.handleEnumerator(D);
109    IndexCtx.indexBody(D->getInitExpr(), D);
110    return true;
111  }
112
113  bool VisitTypedefDecl(TypedefNameDecl *D) {
114    IndexCtx.handleTypedefName(D);
115    IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
116    return true;
117  }
118
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
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
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
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    IndexCtx.indexDeclContext(D);
158    return true;
159  }
160
161  bool VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
162    IndexCtx.handleObjCCategory(D);
163
164    IndexCtx.indexTUDeclsInObjCContainer();
165    IndexCtx.indexDeclContext(D);
166    return true;
167  }
168
169  bool VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
170    const ObjCCategoryDecl *Cat = D->getCategoryDecl();
171    if (!Cat)
172      return true;
173
174    IndexCtx.handleObjCCategoryImpl(D);
175
176    IndexCtx.indexTUDeclsInObjCContainer();
177    IndexCtx.indexDeclContext(D);
178    return true;
179  }
180
181  bool VisitObjCMethodDecl(ObjCMethodDecl *D) {
182    // Methods associated with a property, even user-declared ones, are
183    // handled when we handle the property.
184    if (D->isSynthesized())
185      return true;
186
187    handleObjCMethod(D);
188    return true;
189  }
190
191  bool VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
192    if (ObjCMethodDecl *MD = D->getGetterMethodDecl())
193      if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
194        handleObjCMethod(MD);
195    if (ObjCMethodDecl *MD = D->getSetterMethodDecl())
196      if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
197        handleObjCMethod(MD);
198    IndexCtx.handleObjCProperty(D);
199    IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
200    return true;
201  }
202
203  bool VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
204    ObjCPropertyDecl *PD = D->getPropertyDecl();
205    IndexCtx.handleSynthesizedObjCProperty(D);
206
207    if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
208      return true;
209    assert(D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize);
210
211    if (ObjCIvarDecl *IvarD = D->getPropertyIvarDecl()) {
212      if (!IvarD->getSynthesize())
213        IndexCtx.handleReference(IvarD, D->getPropertyIvarDeclLoc(), 0,
214                                 D->getDeclContext());
215    }
216
217    if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) {
218      if (MD->isSynthesized())
219        IndexCtx.handleSynthesizedObjCMethod(MD, D->getLocation(),
220                                             D->getLexicalDeclContext());
221    }
222    if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) {
223      if (MD->isSynthesized())
224        IndexCtx.handleSynthesizedObjCMethod(MD, D->getLocation(),
225                                             D->getLexicalDeclContext());
226    }
227    return true;
228  }
229
230  bool VisitNamespaceDecl(NamespaceDecl *D) {
231    IndexCtx.handleNamespace(D);
232    IndexCtx.indexDeclContext(D);
233    return true;
234  }
235
236  bool VisitUsingDecl(UsingDecl *D) {
237    // FIXME: Parent for the following is CXIdxEntity_Unexposed with no USR,
238    // we should do better.
239
240    IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
241    for (UsingDecl::shadow_iterator
242           I = D->shadow_begin(), E = D->shadow_end(); I != E; ++I) {
243      IndexCtx.handleReference((*I)->getUnderlyingDecl(), D->getLocation(),
244                               D, D->getLexicalDeclContext());
245    }
246    return true;
247  }
248
249  bool VisitUsingDirectiveDecl(UsingDirectiveDecl *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    IndexCtx.handleReference(D->getNominatedNamespaceAsWritten(),
255                             D->getLocation(), D, D->getLexicalDeclContext());
256    return true;
257  }
258
259  bool VisitClassTemplateDecl(ClassTemplateDecl *D) {
260    IndexCtx.handleClassTemplate(D);
261    if (D->isThisDeclarationADefinition())
262      IndexCtx.indexDeclContext(D->getTemplatedDecl());
263    return true;
264  }
265
266  bool VisitClassTemplateSpecializationDecl(
267                                           ClassTemplateSpecializationDecl *D) {
268    // FIXME: Notify subsequent callbacks if info comes from implicit
269    // instantiation.
270    if (D->isThisDeclarationADefinition() &&
271        (IndexCtx.shouldIndexImplicitTemplateInsts() ||
272         !IndexCtx.isTemplateImplicitInstantiation(D)))
273      IndexCtx.indexTagDecl(D);
274    return true;
275  }
276
277  bool VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
278    IndexCtx.handleFunctionTemplate(D);
279    FunctionDecl *FD = D->getTemplatedDecl();
280    handleDeclarator(FD, D);
281    if (FD->isThisDeclarationADefinition()) {
282      const Stmt *Body = FD->getBody();
283      if (Body) {
284        IndexCtx.indexBody(Body, D, FD);
285      }
286    }
287    return true;
288  }
289
290  bool VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
291    IndexCtx.handleTypeAliasTemplate(D);
292    IndexCtx.indexTypeSourceInfo(D->getTemplatedDecl()->getTypeSourceInfo(), D);
293    return true;
294  }
295};
296
297} // anonymous namespace
298
299void IndexingContext::indexDecl(const Decl *D) {
300  if (D->isImplicit() && shouldIgnoreIfImplicit(D))
301    return;
302
303  bool Handled = IndexingDeclVisitor(*this).Visit(const_cast<Decl*>(D));
304  if (!Handled && isa<DeclContext>(D))
305    indexDeclContext(cast<DeclContext>(D));
306}
307
308void IndexingContext::indexDeclContext(const DeclContext *DC) {
309  for (DeclContext::decl_iterator
310         I = DC->decls_begin(), E = DC->decls_end(); I != E; ++I) {
311    indexDecl(*I);
312  }
313}
314
315void IndexingContext::indexTopLevelDecl(Decl *D) {
316  if (isNotFromSourceFile(D->getLocation()))
317    return;
318
319  if (isa<ObjCMethodDecl>(D))
320    return; // Wait for the objc container.
321
322  indexDecl(D);
323}
324
325void IndexingContext::indexDeclGroupRef(DeclGroupRef DG) {
326  for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
327    indexTopLevelDecl(*I);
328}
329
330void IndexingContext::indexTUDeclsInObjCContainer() {
331  for (unsigned i = 0, e = TUDeclsInObjCContainer.size(); i != e; ++i)
332    indexDeclGroupRef(TUDeclsInObjCContainer[i]);
333  TUDeclsInObjCContainer.clear();
334}
335