src/llvm/tools/clang/tools/libclang/IndexDecl.cpp

   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:
  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 VisitTypedefNameDecl(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
 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
 174   bool VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
 175     IndexCtx.handleObjCCategory(D);
 176
 177     IndexCtx.indexTUDeclsInObjCContainer();
 178     IndexCtx.indexDeclContext(D);
 179     return true;
 180   }
 181
 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
 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
 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
 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
 243   bool VisitNamespaceDecl(NamespaceDecl *D) {
 244     IndexCtx.handleNamespace(D);
 245     IndexCtx.indexDeclContext(D);
 246     return true;
 247   }
 248
 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
 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
 272   bool VisitClassTemplateDecl(ClassTemplateDecl *D) {
 273     IndexCtx.handleClassTemplate(D);
 274     if (D->isThisDeclarationADefinition())
 275       IndexCtx.indexDeclContext(D->getTemplatedDecl());
 276     return true;
 277   }
 278
 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
 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
 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
 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
 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
 328 void IndexingContext::indexTopLevelDecl(const 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
 338 void IndexingContext::indexDeclGroupRef(DeclGroupRef DG) {
 339   for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
 340     indexTopLevelDecl(*I);
 341 }
 342
 343 void IndexingContext::indexTUDeclsInObjCContainer() {
 344   while (!TUDeclsInObjCContainer.empty()) {
 345     DeclGroupRef DG = TUDeclsInObjCContainer.front();
 346     TUDeclsInObjCContainer.pop_front();
 347     indexDeclGroupRef(DG);
 348   }
 349 }