Home | History | Annotate | Download | only in libclang 
      1 //===- IndexingContext.h - Higher level API functions -----------*- C++ -*-===//
      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 "CXCursor.h"
     11 #include "Index_Internal.h"
     12 #include "clang/AST/DeclGroup.h"
     13 #include "clang/AST/DeclObjC.h"
     14 #include "llvm/ADT/DenseSet.h"
     15 #include <deque>
     16 
     17 namespace clang {
     18   class FileEntry;
     19   class MSPropertyDecl;
     20   class ObjCPropertyDecl;
     21   class ClassTemplateDecl;
     22   class FunctionTemplateDecl;
     23   class TypeAliasTemplateDecl;
     24   class ClassTemplateSpecializationDecl;
     25 
     26 namespace cxindex {
     27   class IndexingContext;
     28   class AttrListInfo;
     29 
     30 class ScratchAlloc {
     31   IndexingContext &IdxCtx;
     32 
     33 public:
     34   explicit ScratchAlloc(IndexingContext &indexCtx);
     35   ScratchAlloc(const ScratchAlloc &SA);
     36 
     37   ~ScratchAlloc();
     38 
     39   const char *toCStr(StringRef Str);
     40   const char *copyCStr(StringRef Str);
     41 
     42   template <typename T>
     43   T *allocate();
     44 };
     45 
     46 struct EntityInfo : public CXIdxEntityInfo {
     47   const NamedDecl *Dcl;
     48   IndexingContext *IndexCtx;
     49   IntrusiveRefCntPtr<AttrListInfo> AttrList;
     50 
     51   EntityInfo() {
     52     name = USR = nullptr;
     53     attributes = nullptr;
     54     numAttributes = 0;
     55   }
     56 };
     57 
     58 struct ContainerInfo : public CXIdxContainerInfo {
     59   const DeclContext *DC;
     60   IndexingContext *IndexCtx;
     61 };
     62 
     63 struct DeclInfo : public CXIdxDeclInfo {
     64   enum DInfoKind {
     65     Info_Decl,
     66 
     67     Info_ObjCContainer,
     68       Info_ObjCInterface,
     69       Info_ObjCProtocol,
     70       Info_ObjCCategory,
     71 
     72     Info_ObjCProperty,
     73 
     74     Info_CXXClass
     75   };
     76 
     77   DInfoKind Kind;
     78 
     79   EntityInfo EntInfo;
     80   ContainerInfo SemanticContainer;
     81   ContainerInfo LexicalContainer;
     82   ContainerInfo DeclAsContainer;
     83 
     84   DeclInfo(bool isRedeclaration, bool isDefinition, bool isContainer)
     85     : Kind(Info_Decl) {
     86     this->isRedeclaration = isRedeclaration;
     87     this->isDefinition = isDefinition;
     88     this->isContainer = isContainer;
     89     attributes = nullptr;
     90     numAttributes = 0;
     91     declAsContainer = semanticContainer = lexicalContainer = nullptr;
     92     flags = 0;
     93   }
     94   DeclInfo(DInfoKind K,
     95            bool isRedeclaration, bool isDefinition, bool isContainer)
     96     : Kind(K) {
     97     this->isRedeclaration = isRedeclaration;
     98     this->isDefinition = isDefinition;
     99     this->isContainer = isContainer;
    100     attributes = nullptr;
    101     numAttributes = 0;
    102     declAsContainer = semanticContainer = lexicalContainer = nullptr;
    103     flags = 0;
    104   }
    105 };
    106 
    107 struct ObjCContainerDeclInfo : public DeclInfo {
    108   CXIdxObjCContainerDeclInfo ObjCContDeclInfo;
    109 
    110   ObjCContainerDeclInfo(bool isForwardRef,
    111                         bool isRedeclaration,
    112                         bool isImplementation)
    113     : DeclInfo(Info_ObjCContainer, isRedeclaration,
    114                /*isDefinition=*/!isForwardRef, /*isContainer=*/!isForwardRef) {
    115     init(isForwardRef, isImplementation);
    116   }
    117   ObjCContainerDeclInfo(DInfoKind K,
    118                         bool isForwardRef,
    119                         bool isRedeclaration,
    120                         bool isImplementation)
    121     : DeclInfo(K, isRedeclaration, /*isDefinition=*/!isForwardRef,
    122                /*isContainer=*/!isForwardRef) {
    123     init(isForwardRef, isImplementation);
    124   }
    125 
    126   static bool classof(const DeclInfo *D) {
    127     return Info_ObjCContainer <= D->Kind && D->Kind <= Info_ObjCCategory;
    128   }
    129 
    130 private:
    131   void init(bool isForwardRef, bool isImplementation) {
    132     if (isForwardRef)
    133       ObjCContDeclInfo.kind = CXIdxObjCContainer_ForwardRef;
    134     else if (isImplementation)
    135       ObjCContDeclInfo.kind = CXIdxObjCContainer_Implementation;
    136     else
    137       ObjCContDeclInfo.kind = CXIdxObjCContainer_Interface;
    138   }
    139 };
    140 
    141 struct ObjCInterfaceDeclInfo : public ObjCContainerDeclInfo {
    142   CXIdxObjCInterfaceDeclInfo ObjCInterDeclInfo;
    143   CXIdxObjCProtocolRefListInfo ObjCProtoListInfo;
    144 
    145   ObjCInterfaceDeclInfo(const ObjCInterfaceDecl *D)
    146     : ObjCContainerDeclInfo(Info_ObjCInterface,
    147                             /*isForwardRef=*/false,
    148                             /*isRedeclaration=*/D->getPreviousDecl() != nullptr,
    149                             /*isImplementation=*/false) { }
    150 
    151   static bool classof(const DeclInfo *D) {
    152     return D->Kind == Info_ObjCInterface;
    153   }
    154 };
    155 
    156 struct ObjCProtocolDeclInfo : public ObjCContainerDeclInfo {
    157   CXIdxObjCProtocolRefListInfo ObjCProtoRefListInfo;
    158 
    159   ObjCProtocolDeclInfo(const ObjCProtocolDecl *D)
    160     : ObjCContainerDeclInfo(Info_ObjCProtocol,
    161                             /*isForwardRef=*/false,
    162                             /*isRedeclaration=*/D->getPreviousDecl(),
    163                             /*isImplementation=*/false) { }
    164 
    165   static bool classof(const DeclInfo *D) {
    166     return D->Kind == Info_ObjCProtocol;
    167   }
    168 };
    169 
    170 struct ObjCCategoryDeclInfo : public ObjCContainerDeclInfo {
    171   CXIdxObjCCategoryDeclInfo ObjCCatDeclInfo;
    172   CXIdxObjCProtocolRefListInfo ObjCProtoListInfo;
    173 
    174   explicit ObjCCategoryDeclInfo(bool isImplementation)
    175     : ObjCContainerDeclInfo(Info_ObjCCategory,
    176                             /*isForwardRef=*/false,
    177                             /*isRedeclaration=*/isImplementation,
    178                             /*isImplementation=*/isImplementation) { }
    179 
    180   static bool classof(const DeclInfo *D) {
    181     return D->Kind == Info_ObjCCategory;
    182   }
    183 };
    184 
    185 struct ObjCPropertyDeclInfo : public DeclInfo {
    186   CXIdxObjCPropertyDeclInfo ObjCPropDeclInfo;
    187 
    188   ObjCPropertyDeclInfo()
    189     : DeclInfo(Info_ObjCProperty,
    190                /*isRedeclaration=*/false, /*isDefinition=*/false,
    191                /*isContainer=*/false) { }
    192 
    193   static bool classof(const DeclInfo *D) {
    194     return D->Kind == Info_ObjCProperty;
    195   }
    196 };
    197 
    198 struct CXXClassDeclInfo : public DeclInfo {
    199   CXIdxCXXClassDeclInfo CXXClassInfo;
    200 
    201   CXXClassDeclInfo(bool isRedeclaration, bool isDefinition)
    202     : DeclInfo(Info_CXXClass, isRedeclaration, isDefinition, isDefinition) { }
    203 
    204   static bool classof(const DeclInfo *D) {
    205     return D->Kind == Info_CXXClass;
    206   }
    207 };
    208 
    209 struct AttrInfo : public CXIdxAttrInfo {
    210   const Attr *A;
    211 
    212   AttrInfo(CXIdxAttrKind Kind, CXCursor C, CXIdxLoc Loc, const Attr *A) {
    213     kind = Kind;
    214     cursor = C;
    215     loc = Loc;
    216     this->A = A;
    217   }
    218 };
    219 
    220 struct IBOutletCollectionInfo : public AttrInfo {
    221   EntityInfo ClassInfo;
    222   CXIdxIBOutletCollectionAttrInfo IBCollInfo;
    223 
    224   IBOutletCollectionInfo(CXCursor C, CXIdxLoc Loc, const Attr *A) :
    225     AttrInfo(CXIdxAttr_IBOutletCollection, C, Loc, A) {
    226     assert(C.kind == CXCursor_IBOutletCollectionAttr);
    227     IBCollInfo.objcClass = nullptr;
    228   }
    229 
    230   IBOutletCollectionInfo(const IBOutletCollectionInfo &other);
    231 
    232   static bool classof(const AttrInfo *A) {
    233     return A->kind == CXIdxAttr_IBOutletCollection;
    234   }
    235 };
    236 
    237 class AttrListInfo {
    238   ScratchAlloc SA;
    239 
    240   SmallVector<AttrInfo, 2> Attrs;
    241   SmallVector<IBOutletCollectionInfo, 2> IBCollAttrs;
    242   SmallVector<CXIdxAttrInfo *, 2> CXAttrs;
    243   unsigned ref_cnt;
    244 
    245   AttrListInfo(const AttrListInfo &) LLVM_DELETED_FUNCTION;
    246   void operator=(const AttrListInfo &) LLVM_DELETED_FUNCTION;
    247 public:
    248   AttrListInfo(const Decl *D, IndexingContext &IdxCtx);
    249 
    250   static IntrusiveRefCntPtr<AttrListInfo> create(const Decl *D,
    251                                                  IndexingContext &IdxCtx);
    252 
    253   const CXIdxAttrInfo *const *getAttrs() const {
    254     if (CXAttrs.empty())
    255       return nullptr;
    256     return CXAttrs.data();
    257   }
    258   unsigned getNumAttrs() const { return (unsigned)CXAttrs.size(); }
    259 
    260   /// \brief Retain/Release only useful when we allocate a AttrListInfo from the
    261   /// BumpPtrAllocator, and not from the stack; so that we keep a pointer
    262   // in the EntityInfo
    263   void Retain() { ++ref_cnt; }
    264   void Release() {
    265     assert (ref_cnt > 0 && "Reference count is already zero.");
    266     if (--ref_cnt == 0) {
    267       // Memory is allocated from a BumpPtrAllocator, no need to delete it.
    268       this->~AttrListInfo();
    269     }
    270   }
    271 };
    272 
    273 class IndexingContext {
    274   ASTContext *Ctx;
    275   CXClientData ClientData;
    276   IndexerCallbacks &CB;
    277   unsigned IndexOptions;
    278   CXTranslationUnit CXTU;
    279 
    280   typedef llvm::DenseMap<const FileEntry *, CXIdxClientFile> FileMapTy;
    281   typedef llvm::DenseMap<const DeclContext *, CXIdxClientContainer>
    282     ContainerMapTy;
    283   typedef llvm::DenseMap<const Decl *, CXIdxClientEntity> EntityMapTy;
    284 
    285   FileMapTy FileMap;
    286   ContainerMapTy ContainerMap;
    287   EntityMapTy EntityMap;
    288 
    289   typedef std::pair<const FileEntry *, const Decl *> RefFileOccurrence;
    290   llvm::DenseSet<RefFileOccurrence> RefFileOccurrences;
    291 
    292   std::deque<DeclGroupRef> TUDeclsInObjCContainer;
    293 
    294   llvm::BumpPtrAllocator StrScratch;
    295   unsigned StrAdapterCount;
    296   friend class ScratchAlloc;
    297 
    298   struct ObjCProtocolListInfo {
    299     SmallVector<CXIdxObjCProtocolRefInfo, 4> ProtInfos;
    300     SmallVector<EntityInfo, 4> ProtEntities;
    301     SmallVector<CXIdxObjCProtocolRefInfo *, 4> Prots;
    302 
    303     CXIdxObjCProtocolRefListInfo getListInfo() const {
    304       CXIdxObjCProtocolRefListInfo Info = { Prots.data(),
    305                                             (unsigned)Prots.size() };
    306       return Info;
    307     }
    308 
    309     ObjCProtocolListInfo(const ObjCProtocolList &ProtList,
    310                          IndexingContext &IdxCtx,
    311                          ScratchAlloc &SA);
    312   };
    313 
    314   struct CXXBasesListInfo {
    315     SmallVector<CXIdxBaseClassInfo, 4> BaseInfos;
    316     SmallVector<EntityInfo, 4> BaseEntities;
    317     SmallVector<CXIdxBaseClassInfo *, 4> CXBases;
    318 
    319     const CXIdxBaseClassInfo *const *getBases() const {
    320       return CXBases.data();
    321     }
    322     unsigned getNumBases() const { return (unsigned)CXBases.size(); }
    323 
    324     CXXBasesListInfo(const CXXRecordDecl *D,
    325                      IndexingContext &IdxCtx, ScratchAlloc &SA);
    326 
    327   private:
    328     SourceLocation getBaseLoc(const CXXBaseSpecifier &Base) const;
    329   };
    330 
    331   friend class AttrListInfo;
    332 
    333 public:
    334   IndexingContext(CXClientData clientData, IndexerCallbacks &indexCallbacks,
    335                   unsigned indexOptions, CXTranslationUnit cxTU)
    336     : Ctx(nullptr), ClientData(clientData), CB(indexCallbacks),
    337       IndexOptions(indexOptions), CXTU(cxTU),
    338       StrScratch(), StrAdapterCount(0) { }
    339 
    340   ASTContext &getASTContext() const { return *Ctx; }
    341 
    342   void setASTContext(ASTContext &ctx);
    343   void setPreprocessor(Preprocessor &PP);
    344 
    345   bool shouldSuppressRefs() const {
    346     return IndexOptions & CXIndexOpt_SuppressRedundantRefs;
    347   }
    348 
    349   bool shouldIndexFunctionLocalSymbols() const {
    350     return IndexOptions & CXIndexOpt_IndexFunctionLocalSymbols;
    351   }
    352 
    353   bool shouldIndexImplicitTemplateInsts() const {
    354     return IndexOptions & CXIndexOpt_IndexImplicitTemplateInstantiations;
    355   }
    356 
    357   static bool isFunctionLocalDecl(const Decl *D);
    358 
    359   bool shouldAbort();
    360 
    361   bool hasDiagnosticCallback() const { return CB.diagnostic; }
    362 
    363   void enteredMainFile(const FileEntry *File);
    364 
    365   void ppIncludedFile(SourceLocation hashLoc,
    366                       StringRef filename, const FileEntry *File,
    367                       bool isImport, bool isAngled, bool isModuleImport);
    368 
    369   void importedModule(const ImportDecl *ImportD);
    370   void importedPCH(const FileEntry *File);
    371 
    372   void startedTranslationUnit();
    373 
    374   void indexDecl(const Decl *D);
    375 
    376   void indexTagDecl(const TagDecl *D);
    377 
    378   void indexTypeSourceInfo(TypeSourceInfo *TInfo, const NamedDecl *Parent,
    379                            const DeclContext *DC = nullptr);
    380 
    381   void indexTypeLoc(TypeLoc TL, const NamedDecl *Parent,
    382                     const DeclContext *DC = nullptr);
    383 
    384   void indexNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
    385                                    const NamedDecl *Parent,
    386                                    const DeclContext *DC = nullptr);
    387 
    388   void indexDeclContext(const DeclContext *DC);
    389 
    390   void indexBody(const Stmt *S, const NamedDecl *Parent,
    391                  const DeclContext *DC = nullptr);
    392 
    393   void handleDiagnosticSet(CXDiagnosticSet CXDiagSet);
    394 
    395   bool handleFunction(const FunctionDecl *FD);
    396 
    397   bool handleVar(const VarDecl *D);
    398 
    399   bool handleField(const FieldDecl *D);
    400 
    401   bool handleMSProperty(const MSPropertyDecl *D);
    402 
    403   bool handleEnumerator(const EnumConstantDecl *D);
    404 
    405   bool handleTagDecl(const TagDecl *D);
    406 
    407   bool handleTypedefName(const TypedefNameDecl *D);
    408 
    409   bool handleObjCInterface(const ObjCInterfaceDecl *D);
    410   bool handleObjCImplementation(const ObjCImplementationDecl *D);
    411 
    412   bool handleObjCProtocol(const ObjCProtocolDecl *D);
    413 
    414   bool handleObjCCategory(const ObjCCategoryDecl *D);
    415   bool handleObjCCategoryImpl(const ObjCCategoryImplDecl *D);
    416 
    417   bool handleObjCMethod(const ObjCMethodDecl *D);
    418 
    419   bool handleSynthesizedObjCProperty(const ObjCPropertyImplDecl *D);
    420   bool handleSynthesizedObjCMethod(const ObjCMethodDecl *D, SourceLocation Loc,
    421                                    const DeclContext *LexicalDC);
    422 
    423   bool handleObjCProperty(const ObjCPropertyDecl *D);
    424 
    425   bool handleNamespace(const NamespaceDecl *D);
    426 
    427   bool handleClassTemplate(const ClassTemplateDecl *D);
    428   bool handleFunctionTemplate(const FunctionTemplateDecl *D);
    429   bool handleTypeAliasTemplate(const TypeAliasTemplateDecl *D);
    430 
    431   bool handleReference(const NamedDecl *D, SourceLocation Loc, CXCursor Cursor,
    432                        const NamedDecl *Parent,
    433                        const DeclContext *DC,
    434                        const Expr *E = nullptr,
    435                        CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct);
    436 
    437   bool handleReference(const NamedDecl *D, SourceLocation Loc,
    438                        const NamedDecl *Parent,
    439                        const DeclContext *DC,
    440                        const Expr *E = nullptr,
    441                        CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct);
    442 
    443   bool isNotFromSourceFile(SourceLocation Loc) const;
    444 
    445   void indexTopLevelDecl(const Decl *D);
    446   void indexTUDeclsInObjCContainer();
    447   void indexDeclGroupRef(DeclGroupRef DG);
    448 
    449   void addTUDeclInObjCContainer(DeclGroupRef DG) {
    450     TUDeclsInObjCContainer.push_back(DG);
    451   }
    452 
    453   void translateLoc(SourceLocation Loc, CXIdxClientFile *indexFile, CXFile *file,
    454                     unsigned *line, unsigned *column, unsigned *offset);
    455 
    456   CXIdxClientContainer getClientContainerForDC(const DeclContext *DC) const;
    457   void addContainerInMap(const DeclContext *DC, CXIdxClientContainer container);
    458 
    459   CXIdxClientEntity getClientEntity(const Decl *D) const;
    460   void setClientEntity(const Decl *D, CXIdxClientEntity client);
    461 
    462   static bool isTemplateImplicitInstantiation(const Decl *D);
    463 
    464 private:
    465   bool handleDecl(const NamedDecl *D,
    466                   SourceLocation Loc, CXCursor Cursor,
    467                   DeclInfo &DInfo,
    468                   const DeclContext *LexicalDC = nullptr);
    469 
    470   bool handleObjCContainer(const ObjCContainerDecl *D,
    471                            SourceLocation Loc, CXCursor Cursor,
    472                            ObjCContainerDeclInfo &ContDInfo);
    473 
    474   bool handleCXXRecordDecl(const CXXRecordDecl *RD, const NamedDecl *OrigD);
    475 
    476   bool markEntityOccurrenceInFile(const NamedDecl *D, SourceLocation Loc);
    477 
    478   const NamedDecl *getEntityDecl(const NamedDecl *D) const;
    479 
    480   const DeclContext *getEntityContainer(const Decl *D) const;
    481 
    482   CXIdxClientFile getIndexFile(const FileEntry *File);
    483 
    484   CXIdxLoc getIndexLoc(SourceLocation Loc) const;
    485 
    486   void getEntityInfo(const NamedDecl *D,
    487                      EntityInfo &EntityInfo,
    488                      ScratchAlloc &SA);
    489 
    490   void getContainerInfo(const DeclContext *DC, ContainerInfo &ContInfo);
    491 
    492   CXCursor getCursor(const Decl *D) {
    493     return cxcursor::MakeCXCursor(D, CXTU);
    494   }
    495 
    496   CXCursor getRefCursor(const NamedDecl *D, SourceLocation Loc);
    497 
    498   static bool shouldIgnoreIfImplicit(const Decl *D);
    499 };
    500 
    501 inline ScratchAlloc::ScratchAlloc(IndexingContext &idxCtx) : IdxCtx(idxCtx) {
    502   ++IdxCtx.StrAdapterCount;
    503 }
    504 inline ScratchAlloc::ScratchAlloc(const ScratchAlloc &SA) : IdxCtx(SA.IdxCtx) {
    505   ++IdxCtx.StrAdapterCount;
    506 }
    507 
    508 inline ScratchAlloc::~ScratchAlloc() {
    509   --IdxCtx.StrAdapterCount;
    510   if (IdxCtx.StrAdapterCount == 0)
    511     IdxCtx.StrScratch.Reset();
    512 }
    513 
    514 template <typename T>
    515 inline T *ScratchAlloc::allocate() {
    516   return IdxCtx.StrScratch.Allocate<T>();
    517 }
    518 
    519 }} // end clang::cxindex
    520