CXIndexDataConsumer.h source code [clang_source_code/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	(0) . __assert_fail ("ref_cnt > 0 && \"Reference count is already zero.\"", "/home/seafit/code_projects/clang_source/clang/tools/libclang/CXIndexDataConsumer.h", 267, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">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 indexDecl(const Decl *D);
376
377	void indexTagDecl(const TagDecl *D);
378
379	void indexTypeSourceInfo(TypeSourceInfo TInfo, const NamedDecl Parent,
380	const DeclContext *DC = nullptr);
381
382	void indexTypeLoc(TypeLoc TL, const NamedDecl *Parent,
383	const DeclContext *DC = nullptr);
384
385	void indexNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
386	const NamedDecl *Parent,
387	const DeclContext *DC = nullptr);
388
389	void indexDeclContext(const DeclContext *DC);
390
391	void indexBody(const Stmt S, const NamedDecl Parent,
392	const DeclContext *DC = nullptr);
393
394	void indexDiagnostics();
395
396	void handleDiagnosticSet(CXDiagnosticSet CXDiagSet);
397
398	bool handleFunction(const FunctionDecl *FD);
399
400	bool handleVar(const VarDecl *D);
401
402	bool handleField(const FieldDecl *D);
403
404	bool handleMSProperty(const MSPropertyDecl *D);
405
406	bool handleEnumerator(const EnumConstantDecl *D);
407
408	bool handleTagDecl(const TagDecl *D);
409
410	bool handleTypedefName(const TypedefNameDecl *D);
411
412	bool handleObjCInterface(const ObjCInterfaceDecl *D);
413	bool handleObjCImplementation(const ObjCImplementationDecl *D);
414
415	bool handleObjCProtocol(const ObjCProtocolDecl *D);
416
417	bool handleObjCCategory(const ObjCCategoryDecl *D);
418	bool handleObjCCategoryImpl(const ObjCCategoryImplDecl *D);
419
420	bool handleObjCMethod(const ObjCMethodDecl *D, SourceLocation Loc);
421
422	bool handleSynthesizedObjCProperty(const ObjCPropertyImplDecl *D);
423	bool handleSynthesizedObjCMethod(const ObjCMethodDecl *D, SourceLocation Loc,
424	const DeclContext *LexicalDC);
425
426	bool handleObjCProperty(const ObjCPropertyDecl *D);
427
428	bool handleNamespace(const NamespaceDecl *D);
429
430	bool handleClassTemplate(const ClassTemplateDecl *D);
431	bool handleFunctionTemplate(const FunctionTemplateDecl *D);
432	bool handleTypeAliasTemplate(const TypeAliasTemplateDecl *D);
433
434	bool handleReference(const NamedDecl *D, SourceLocation Loc, CXCursor Cursor,
435	const NamedDecl *Parent,
436	const DeclContext *DC,
437	const Expr *E = nullptr,
438	CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct,
439	CXSymbolRole Role = CXSymbolRole_None);
440
441	bool handleReference(const NamedDecl *D, SourceLocation Loc,
442	const NamedDecl *Parent,
443	const DeclContext *DC,
444	const Expr *E = nullptr,
445	CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct,
446	CXSymbolRole Role = CXSymbolRole_None);
447
448	bool isNotFromSourceFile(SourceLocation Loc) const;
449
450	void indexTopLevelDecl(const Decl *D);
451	void indexDeclGroupRef(DeclGroupRef DG);
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 handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
466	ArrayRef<index::SymbolRelation> Relations,
467	SourceLocation Loc, ASTNodeInfo ASTNode) override;
468
469	bool handleModuleOccurence(const ImportDecl ImportD, const Module Mod,
470	index::SymbolRoleSet Roles,
471	SourceLocation Loc) override;
472
473	void finish() override;
474
475	bool handleDecl(const NamedDecl *D,
476	SourceLocation Loc, CXCursor Cursor,
477	DeclInfo &DInfo,
478	const DeclContext *LexicalDC = nullptr,
479	const DeclContext *SemaDC = nullptr);
480
481	bool handleObjCContainer(const ObjCContainerDecl *D,
482	SourceLocation Loc, CXCursor Cursor,
483	ObjCContainerDeclInfo &ContDInfo);
484
485	bool handleCXXRecordDecl(const CXXRecordDecl RD, const NamedDecl OrigD);
486
487	bool markEntityOccurrenceInFile(const NamedDecl *D, SourceLocation Loc);
488
489	const NamedDecl getEntityDecl(const NamedDecl D) const;
490
491	const DeclContext getEntityContainer(const Decl D) const;
492
493	CXIdxClientFile getIndexFile(const FileEntry *File);
494
495	CXIdxLoc getIndexLoc(SourceLocation Loc) const;
496
497	void getEntityInfo(const NamedDecl *D,
498	EntityInfo &EntityInfo,
499	ScratchAlloc &SA);
500
501	void getContainerInfo(const DeclContext *DC, ContainerInfo &ContInfo);
502
503	CXCursor getCursor(const Decl *D) {
504	return cxcursor::MakeCXCursor(D, CXTU);
505	}
506
507	CXCursor getRefCursor(const NamedDecl *D, SourceLocation Loc);
508
509	static bool shouldIgnoreIfImplicit(const Decl *D);
510	};
511
512	inline ScratchAlloc::ScratchAlloc(CXIndexDataConsumer &idxCtx) : IdxCtx(idxCtx) {
513	++IdxCtx.StrAdapterCount;
514	}
515	inline ScratchAlloc::ScratchAlloc(const ScratchAlloc &SA) : IdxCtx(SA.IdxCtx) {
516	++IdxCtx.StrAdapterCount;
517	}
518
519	inline ScratchAlloc::~ScratchAlloc() {
520	--IdxCtx.StrAdapterCount;
521	if (IdxCtx.StrAdapterCount == 0)
522	IdxCtx.StrScratch.Reset();
523	}
524
525	template <typename T>
526	inline T *ScratchAlloc::allocate() {
527	return IdxCtx.StrScratch.Allocate<T>();
528	}
529
530	}} // end clang::cxindex
531
532	#endif
533