xref: /openbsd-src/gnu/llvm/clang/tools/libclang/CXIndexDataConsumer.h (revision 1a8dbaac879b9f3335ad7fb25429ce63ac1d6bac) 
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),
338       StrScratch(), StrAdapterCount(0) { }
339 
340   ASTContext &getASTContext() const { return *Ctx; }
341   CXTranslationUnit getCXTU() const { return CXTU; }
342 
343   void setASTContext(ASTContext &ctx);
344   void setPreprocessor(std::shared_ptr<Preprocessor> PP) override;
345 
346   bool shouldSuppressRefs() const {
347     return IndexOptions & CXIndexOpt_SuppressRedundantRefs;
348   }
349 
350   bool shouldIndexFunctionLocalSymbols() const {
351     return IndexOptions & CXIndexOpt_IndexFunctionLocalSymbols;
352   }
353 
354   bool shouldIndexImplicitTemplateInsts() const {
355     return IndexOptions & CXIndexOpt_IndexImplicitTemplateInstantiations;
356   }
357 
358   static bool isFunctionLocalDecl(const Decl *D);
359 
360   bool shouldAbort();
361 
362   bool hasDiagnosticCallback() const { return CB.diagnostic; }
363 
364   void enteredMainFile(const FileEntry *File);
365 
366   void ppIncludedFile(SourceLocation hashLoc,
367                       StringRef filename, const FileEntry *File,
368                       bool isImport, bool isAngled, bool isModuleImport);
369 
370   void importedModule(const ImportDecl *ImportD);
371   void importedPCH(const FileEntry *File);
372 
373   void startedTranslationUnit();
374 
375   void indexDiagnostics();
376 
377   void handleDiagnosticSet(CXDiagnosticSet CXDiagSet);
378 
379   bool handleFunction(const FunctionDecl *FD);
380 
381   bool handleVar(const VarDecl *D);
382 
383   bool handleField(const FieldDecl *D);
384 
385   bool handleEnumerator(const EnumConstantDecl *D);
386 
387   bool handleTagDecl(const TagDecl *D);
388 
389   bool handleTypedefName(const TypedefNameDecl *D);
390 
391   bool handleObjCInterface(const ObjCInterfaceDecl *D);
392   bool handleObjCImplementation(const ObjCImplementationDecl *D);
393 
394   bool handleObjCProtocol(const ObjCProtocolDecl *D);
395 
396   bool handleObjCCategory(const ObjCCategoryDecl *D);
397   bool handleObjCCategoryImpl(const ObjCCategoryImplDecl *D);
398 
399   bool handleObjCMethod(const ObjCMethodDecl *D, SourceLocation Loc);
400 
401   bool handleSynthesizedObjCProperty(const ObjCPropertyImplDecl *D);
402   bool handleSynthesizedObjCMethod(const ObjCMethodDecl *D, SourceLocation Loc,
403                                    const DeclContext *LexicalDC);
404 
405   bool handleObjCProperty(const ObjCPropertyDecl *D);
406 
407   bool handleNamespace(const NamespaceDecl *D);
408 
409   bool handleClassTemplate(const ClassTemplateDecl *D);
410   bool handleFunctionTemplate(const FunctionTemplateDecl *D);
411   bool handleTypeAliasTemplate(const TypeAliasTemplateDecl *D);
412 
413   bool handleReference(const NamedDecl *D, SourceLocation Loc, CXCursor Cursor,
414                        const NamedDecl *Parent,
415                        const DeclContext *DC,
416                        const Expr *E = nullptr,
417                        CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct,
418                        CXSymbolRole Role = CXSymbolRole_None);
419 
420   bool isNotFromSourceFile(SourceLocation Loc) const;
421 
422   void translateLoc(SourceLocation Loc, CXIdxClientFile *indexFile, CXFile *file,
423                     unsigned *line, unsigned *column, unsigned *offset);
424 
425   CXIdxClientContainer getClientContainerForDC(const DeclContext *DC) const;
426   void addContainerInMap(const DeclContext *DC, CXIdxClientContainer container);
427 
428   CXIdxClientEntity getClientEntity(const Decl *D) const;
429   void setClientEntity(const Decl *D, CXIdxClientEntity client);
430 
431   static bool isTemplateImplicitInstantiation(const Decl *D);
432 
433 private:
434   bool handleDeclOccurrence(const Decl *D, index::SymbolRoleSet Roles,
435                             ArrayRef<index::SymbolRelation> Relations,
436                             SourceLocation Loc, ASTNodeInfo ASTNode) override;
437 
438   bool handleModuleOccurrence(const ImportDecl *ImportD, const Module *Mod,
439                               index::SymbolRoleSet Roles,
440                               SourceLocation Loc) override;
441 
442   void finish() override;
443 
444   bool handleDecl(const NamedDecl *D,
445                   SourceLocation Loc, CXCursor Cursor,
446                   DeclInfo &DInfo,
447                   const DeclContext *LexicalDC = nullptr,
448                   const DeclContext *SemaDC = nullptr);
449 
450   bool handleObjCContainer(const ObjCContainerDecl *D,
451                            SourceLocation Loc, CXCursor Cursor,
452                            ObjCContainerDeclInfo &ContDInfo);
453 
454   bool handleCXXRecordDecl(const CXXRecordDecl *RD, const NamedDecl *OrigD);
455 
456   bool markEntityOccurrenceInFile(const NamedDecl *D, SourceLocation Loc);
457 
458   const NamedDecl *getEntityDecl(const NamedDecl *D) const;
459 
460   const DeclContext *getEntityContainer(const Decl *D) const;
461 
462   CXIdxClientFile getIndexFile(const FileEntry *File);
463 
464   CXIdxLoc getIndexLoc(SourceLocation Loc) const;
465 
466   void getEntityInfo(const NamedDecl *D,
467                      EntityInfo &EntityInfo,
468                      ScratchAlloc &SA);
469 
470   void getContainerInfo(const DeclContext *DC, ContainerInfo &ContInfo);
471 
472   CXCursor getCursor(const Decl *D) {
473     return cxcursor::MakeCXCursor(D, CXTU);
474   }
475 
476   CXCursor getRefCursor(const NamedDecl *D, SourceLocation Loc);
477 
478   static bool shouldIgnoreIfImplicit(const Decl *D);
479 };
480 
481 inline ScratchAlloc::ScratchAlloc(CXIndexDataConsumer &idxCtx) : IdxCtx(idxCtx) {
482   ++IdxCtx.StrAdapterCount;
483 }
484 inline ScratchAlloc::ScratchAlloc(const ScratchAlloc &SA) : IdxCtx(SA.IdxCtx) {
485   ++IdxCtx.StrAdapterCount;
486 }
487 
488 inline ScratchAlloc::~ScratchAlloc() {
489   --IdxCtx.StrAdapterCount;
490   if (IdxCtx.StrAdapterCount == 0)
491     IdxCtx.StrScratch.Reset();
492 }
493 
494 template <typename T>
495 inline T *ScratchAlloc::allocate() {
496   return IdxCtx.StrScratch.Allocate<T>();
497 }
498 
499 }} // end clang::cxindex
500 
501 #endif
502