clang/tools/libclang/CXIndexDataConsumer.h

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