ExternalSemaSource.h source code [clang_source_code/include/clang/Sema/ExternalSemaSource.h]

1	//===--- ExternalSemaSource.h - External Sema Interface ---------- 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	// This file defines the ExternalSemaSource interface.
10	//
11	//===----------------------------------------------------------------------===//
12	#ifndef LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H
13	#define LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H
14
15	#include "clang/AST/ExternalASTSource.h"
16	#include "clang/AST/Type.h"
17	#include "clang/Sema/TypoCorrection.h"
18	#include "clang/Sema/Weak.h"
19	#include "llvm/ADT/MapVector.h"
20	#include <utility>
21
22	namespace llvm {
23	template <class T, unsigned n> class SmallSetVector;
24	}
25
26	namespace clang {
27
28	class CXXConstructorDecl;
29	class CXXDeleteExpr;
30	class CXXRecordDecl;
31	class DeclaratorDecl;
32	class LookupResult;
33	struct ObjCMethodList;
34	class Scope;
35	class Sema;
36	class TypedefNameDecl;
37	class ValueDecl;
38	class VarDecl;
39	struct LateParsedTemplate;
40
41	/// A simple structure that captures a vtable use for the purposes of
42	/// the \c ExternalSemaSource.
43	struct ExternalVTableUse {
44	CXXRecordDecl *Record;
45	SourceLocation Location;
46	bool DefinitionRequired;
47	};
48
49	/// An abstract interface that should be implemented by
50	/// external AST sources that also provide information for semantic
51	/// analysis.
52	class ExternalSemaSource : public ExternalASTSource {
53	public:
54	ExternalSemaSource() {
55	ExternalASTSource::SemaSource = true;
56	}
57
58	~ExternalSemaSource() override;
59
60	/// Initialize the semantic source with the Sema instance
61	/// being used to perform semantic analysis on the abstract syntax
62	/// tree.
63	virtual void InitializeSema(Sema &S) {}
64
65	/// Inform the semantic consumer that Sema is no longer available.
66	virtual void ForgetSema() {}
67
68	/// Load the contents of the global method pool for a given
69	/// selector.
70	virtual void ReadMethodPool(Selector Sel);
71
72	/// Load the contents of the global method pool for a given
73	/// selector if necessary.
74	virtual void updateOutOfDateSelector(Selector Sel);
75
76	/// Load the set of namespaces that are known to the external source,
77	/// which will be used during typo correction.
78	virtual void ReadKnownNamespaces(
79	SmallVectorImpl<NamespaceDecl *> &Namespaces);
80
81	/// Load the set of used but not defined functions or variables with
82	/// internal linkage, or used but not defined internal functions.
83	virtual void
84	ReadUndefinedButUsed(llvm::MapVector<NamedDecl *, SourceLocation> &Undefined);
85
86	virtual void ReadMismatchingDeleteExpressions(llvm::MapVector<
87	FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &);
88
89	/// Do last resort, unqualified lookup on a LookupResult that
90	/// Sema cannot find.
91	///
92	/// \param R a LookupResult that is being recovered.
93	///
94	/// \param S the Scope of the identifier occurrence.
95	///
96	/// \return true to tell Sema to recover using the LookupResult.
97	virtual bool LookupUnqualified(LookupResult &R, Scope *S) { return false; }
98
99	/// Read the set of tentative definitions known to the external Sema
100	/// source.
101	///
102	/// The external source should append its own tentative definitions to the
103	/// given vector of tentative definitions. Note that this routine may be
104	/// invoked multiple times; the external source should take care not to
105	/// introduce the same declarations repeatedly.
106	virtual void ReadTentativeDefinitions(
107	SmallVectorImpl<VarDecl *> &TentativeDefs) {}
108
109	/// Read the set of unused file-scope declarations known to the
110	/// external Sema source.
111	///
112	/// The external source should append its own unused, filed-scope to the
113	/// given vector of declarations. Note that this routine may be
114	/// invoked multiple times; the external source should take care not to
115	/// introduce the same declarations repeatedly.
116	virtual void ReadUnusedFileScopedDecls(
117	SmallVectorImpl<const DeclaratorDecl *> &Decls) {}
118
119	/// Read the set of delegating constructors known to the
120	/// external Sema source.
121	///
122	/// The external source should append its own delegating constructors to the
123	/// given vector of declarations. Note that this routine may be
124	/// invoked multiple times; the external source should take care not to
125	/// introduce the same declarations repeatedly.
126	virtual void ReadDelegatingConstructors(
127	SmallVectorImpl<CXXConstructorDecl *> &Decls) {}
128
129	/// Read the set of ext_vector type declarations known to the
130	/// external Sema source.
131	///
132	/// The external source should append its own ext_vector type declarations to
133	/// the given vector of declarations. Note that this routine may be
134	/// invoked multiple times; the external source should take care not to
135	/// introduce the same declarations repeatedly.
136	virtual void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {}
137
138	/// Read the set of potentially unused typedefs known to the source.
139	///
140	/// The external source should append its own potentially unused local
141	/// typedefs to the given vector of declarations. Note that this routine may
142	/// be invoked multiple times; the external source should take care not to
143	/// introduce the same declarations repeatedly.
144	virtual void ReadUnusedLocalTypedefNameCandidates(
145	llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {}
146
147	/// Read the set of referenced selectors known to the
148	/// external Sema source.
149	///
150	/// The external source should append its own referenced selectors to the
151	/// given vector of selectors. Note that this routine
152	/// may be invoked multiple times; the external source should take care not
153	/// to introduce the same selectors repeatedly.
154	virtual void ReadReferencedSelectors(
155	SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {}
156
157	/// Read the set of weak, undeclared identifiers known to the
158	/// external Sema source.
159	///
160	/// The external source should append its own weak, undeclared identifiers to
161	/// the given vector. Note that this routine may be invoked multiple times;
162	/// the external source should take care not to introduce the same identifiers
163	/// repeatedly.
164	virtual void ReadWeakUndeclaredIdentifiers(
165	SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WI) {}
166
167	/// Read the set of used vtables known to the external Sema source.
168	///
169	/// The external source should append its own used vtables to the given
170	/// vector. Note that this routine may be invoked multiple times; the external
171	/// source should take care not to introduce the same vtables repeatedly.
172	virtual void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {}
173
174	/// Read the set of pending instantiations known to the external
175	/// Sema source.
176	///
177	/// The external source should append its own pending instantiations to the
178	/// given vector. Note that this routine may be invoked multiple times; the
179	/// external source should take care not to introduce the same instantiations
180	/// repeatedly.
181	virtual void ReadPendingInstantiations(
182	SmallVectorImpl<std::pair<ValueDecl *,
183	SourceLocation> > &Pending) {}
184
185	/// Read the set of late parsed template functions for this source.
186	///
187	/// The external source should insert its own late parsed template functions
188	/// into the map. Note that this routine may be invoked multiple times; the
189	/// external source should take care not to introduce the same map entries
190	/// repeatedly.
191	virtual void ReadLateParsedTemplates(
192	llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
193	&LPTMap) {}
194
195	/// \copydoc Sema::CorrectTypo
196	/// \note LookupKind must correspond to a valid Sema::LookupNameKind
197	///
198	/// ExternalSemaSource::CorrectTypo is always given the first chance to
199	/// correct a typo (really, to offer suggestions to repair a failed lookup).
200	/// It will even be called when SpellChecking is turned off or after a
201	/// fatal error has already been detected.
202	virtual TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
203	int LookupKind, Scope S, CXXScopeSpec SS,
204	CorrectionCandidateCallback &CCC,
205	DeclContext *MemberContext,
206	bool EnteringContext,
207	const ObjCObjectPointerType *OPT) {
208	return TypoCorrection();
209	}
210
211	/// Produces a diagnostic note if the external source contains a
212	/// complete definition for \p T.
213	///
214	/// \param Loc the location at which a complete type was required but not
215	/// provided
216	///
217	/// \param T the \c QualType that should have been complete at \p Loc
218	///
219	/// \return true if a diagnostic was produced, false otherwise.
220	virtual bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc,
221	QualType T) {
222	return false;
223	}
224
225	// isa/cast/dyn_cast support
226	static bool classof(const ExternalASTSource *Source) {
227	return Source->SemaSource;
228	}
229	};
230
231	} // end namespace clang
232
233	#endif
234