1 | //===--- MultiplexExternalSemaSource.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 ExternalSemaSource interface, dispatching to all clients |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | #ifndef LLVM_CLANG_SEMA_MULTIPLEXEXTERNALSEMASOURCE_H |
13 | #define LLVM_CLANG_SEMA_MULTIPLEXEXTERNALSEMASOURCE_H |
14 | |
15 | #include "clang/Sema/ExternalSemaSource.h" |
16 | #include "clang/Sema/Weak.h" |
17 | #include "llvm/ADT/SmallVector.h" |
18 | #include <utility> |
19 | |
20 | namespace clang { |
21 | |
22 | class CXXConstructorDecl; |
23 | class CXXRecordDecl; |
24 | class DeclaratorDecl; |
25 | struct ExternalVTableUse; |
26 | class LookupResult; |
27 | class NamespaceDecl; |
28 | class Scope; |
29 | class Sema; |
30 | class TypedefNameDecl; |
31 | class ValueDecl; |
32 | class VarDecl; |
33 | |
34 | |
35 | /// An abstract interface that should be implemented by |
36 | /// external AST sources that also provide information for semantic |
37 | /// analysis. |
38 | class MultiplexExternalSemaSource : public ExternalSemaSource { |
39 | /// LLVM-style RTTI. |
40 | static char ID; |
41 | |
42 | private: |
43 | SmallVector<ExternalSemaSource *, 2> Sources; |
44 | |
45 | public: |
46 | /// Constructs a new multiplexing external sema source and appends the |
47 | /// given element to it. |
48 | /// |
49 | ///\param[in] S1 - A non-null (old) ExternalSemaSource. |
50 | ///\param[in] S2 - A non-null (new) ExternalSemaSource. |
51 | /// |
52 | MultiplexExternalSemaSource(ExternalSemaSource *S1, ExternalSemaSource *S2); |
53 | |
54 | ~MultiplexExternalSemaSource() override; |
55 | |
56 | /// Appends new source to the source list. |
57 | /// |
58 | ///\param[in] Source - An ExternalSemaSource. |
59 | /// |
60 | void AddSource(ExternalSemaSource *Source); |
61 | |
62 | //===--------------------------------------------------------------------===// |
63 | // ExternalASTSource. |
64 | //===--------------------------------------------------------------------===// |
65 | |
66 | /// Resolve a declaration ID into a declaration, potentially |
67 | /// building a new declaration. |
68 | Decl *GetExternalDecl(uint32_t ID) override; |
69 | |
70 | /// Complete the redeclaration chain if it's been extended since the |
71 | /// previous generation of the AST source. |
72 | void CompleteRedeclChain(const Decl *D) override; |
73 | |
74 | /// Resolve a selector ID into a selector. |
75 | Selector GetExternalSelector(uint32_t ID) override; |
76 | |
77 | /// Returns the number of selectors known to the external AST |
78 | /// source. |
79 | uint32_t GetNumExternalSelectors() override; |
80 | |
81 | /// Resolve the offset of a statement in the decl stream into |
82 | /// a statement. |
83 | Stmt *GetExternalDeclStmt(uint64_t Offset) override; |
84 | |
85 | /// Resolve the offset of a set of C++ base specifiers in the decl |
86 | /// stream into an array of specifiers. |
87 | CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset) override; |
88 | |
89 | /// Resolve a handle to a list of ctor initializers into the list of |
90 | /// initializers themselves. |
91 | CXXCtorInitializer **GetExternalCXXCtorInitializers(uint64_t Offset) override; |
92 | |
93 | ExtKind hasExternalDefinitions(const Decl *D) override; |
94 | |
95 | /// Find all declarations with the given name in the |
96 | /// given context. |
97 | bool FindExternalVisibleDeclsByName(const DeclContext *DC, |
98 | DeclarationName Name) override; |
99 | |
100 | /// Ensures that the table of all visible declarations inside this |
101 | /// context is up to date. |
102 | void completeVisibleDeclsMap(const DeclContext *DC) override; |
103 | |
104 | /// Finds all declarations lexically contained within the given |
105 | /// DeclContext, after applying an optional filter predicate. |
106 | /// |
107 | /// \param IsKindWeWant a predicate function that returns true if the passed |
108 | /// declaration kind is one we are looking for. |
109 | void |
110 | FindExternalLexicalDecls(const DeclContext *DC, |
111 | llvm::function_ref<bool(Decl::Kind)> IsKindWeWant, |
112 | SmallVectorImpl<Decl *> &Result) override; |
113 | |
114 | /// Get the decls that are contained in a file in the Offset/Length |
115 | /// range. \p Length can be 0 to indicate a point at \p Offset instead of |
116 | /// a range. |
117 | void FindFileRegionDecls(FileID File, unsigned Offset,unsigned Length, |
118 | SmallVectorImpl<Decl *> &Decls) override; |
119 | |
120 | /// Gives the external AST source an opportunity to complete |
121 | /// an incomplete type. |
122 | void CompleteType(TagDecl *Tag) override; |
123 | |
124 | /// Gives the external AST source an opportunity to complete an |
125 | /// incomplete Objective-C class. |
126 | /// |
127 | /// This routine will only be invoked if the "externally completed" bit is |
128 | /// set on the ObjCInterfaceDecl via the function |
129 | /// \c ObjCInterfaceDecl::setExternallyCompleted(). |
130 | void CompleteType(ObjCInterfaceDecl *Class) override; |
131 | |
132 | /// Loads comment ranges. |
133 | void () override; |
134 | |
135 | /// Notify ExternalASTSource that we started deserialization of |
136 | /// a decl or type so until FinishedDeserializing is called there may be |
137 | /// decls that are initializing. Must be paired with FinishedDeserializing. |
138 | void StartedDeserializing() override; |
139 | |
140 | /// Notify ExternalASTSource that we finished the deserialization of |
141 | /// a decl or type. Must be paired with StartedDeserializing. |
142 | void FinishedDeserializing() override; |
143 | |
144 | /// Function that will be invoked when we begin parsing a new |
145 | /// translation unit involving this external AST source. |
146 | void StartTranslationUnit(ASTConsumer *Consumer) override; |
147 | |
148 | /// Print any statistics that have been gathered regarding |
149 | /// the external AST source. |
150 | void PrintStats() override; |
151 | |
152 | /// Retrieve the module that corresponds to the given module ID. |
153 | Module *getModule(unsigned ID) override; |
154 | |
155 | /// Perform layout on the given record. |
156 | /// |
157 | /// This routine allows the external AST source to provide an specific |
158 | /// layout for a record, overriding the layout that would normally be |
159 | /// constructed. It is intended for clients who receive specific layout |
160 | /// details rather than source code (such as LLDB). The client is expected |
161 | /// to fill in the field offsets, base offsets, virtual base offsets, and |
162 | /// complete object size. |
163 | /// |
164 | /// \param Record The record whose layout is being requested. |
165 | /// |
166 | /// \param Size The final size of the record, in bits. |
167 | /// |
168 | /// \param Alignment The final alignment of the record, in bits. |
169 | /// |
170 | /// \param FieldOffsets The offset of each of the fields within the record, |
171 | /// expressed in bits. All of the fields must be provided with offsets. |
172 | /// |
173 | /// \param BaseOffsets The offset of each of the direct, non-virtual base |
174 | /// classes. If any bases are not given offsets, the bases will be laid |
175 | /// out according to the ABI. |
176 | /// |
177 | /// \param VirtualBaseOffsets The offset of each of the virtual base classes |
178 | /// (either direct or not). If any bases are not given offsets, the bases will |
179 | /// be laid out according to the ABI. |
180 | /// |
181 | /// \returns true if the record layout was provided, false otherwise. |
182 | bool |
183 | layoutRecordType(const RecordDecl *Record, |
184 | uint64_t &Size, uint64_t &Alignment, |
185 | llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets, |
186 | llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets, |
187 | llvm::DenseMap<const CXXRecordDecl *, |
188 | CharUnits> &VirtualBaseOffsets) override; |
189 | |
190 | /// Return the amount of memory used by memory buffers, breaking down |
191 | /// by heap-backed versus mmap'ed memory. |
192 | void getMemoryBufferSizes(MemoryBufferSizes &sizes) const override; |
193 | |
194 | //===--------------------------------------------------------------------===// |
195 | // ExternalSemaSource. |
196 | //===--------------------------------------------------------------------===// |
197 | |
198 | /// Initialize the semantic source with the Sema instance |
199 | /// being used to perform semantic analysis on the abstract syntax |
200 | /// tree. |
201 | void InitializeSema(Sema &S) override; |
202 | |
203 | /// Inform the semantic consumer that Sema is no longer available. |
204 | void ForgetSema() override; |
205 | |
206 | /// Load the contents of the global method pool for a given |
207 | /// selector. |
208 | void ReadMethodPool(Selector Sel) override; |
209 | |
210 | /// Load the contents of the global method pool for a given |
211 | /// selector if necessary. |
212 | void updateOutOfDateSelector(Selector Sel) override; |
213 | |
214 | /// Load the set of namespaces that are known to the external source, |
215 | /// which will be used during typo correction. |
216 | void |
217 | ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl*> &Namespaces) override; |
218 | |
219 | /// Load the set of used but not defined functions or variables with |
220 | /// internal linkage, or used but not defined inline functions. |
221 | void ReadUndefinedButUsed( |
222 | llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) override; |
223 | |
224 | void ReadMismatchingDeleteExpressions(llvm::MapVector< |
225 | FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> & |
226 | Exprs) override; |
227 | |
228 | /// Do last resort, unqualified lookup on a LookupResult that |
229 | /// Sema cannot find. |
230 | /// |
231 | /// \param R a LookupResult that is being recovered. |
232 | /// |
233 | /// \param S the Scope of the identifier occurrence. |
234 | /// |
235 | /// \return true to tell Sema to recover using the LookupResult. |
236 | bool LookupUnqualified(LookupResult &R, Scope *S) override; |
237 | |
238 | /// Read the set of tentative definitions known to the external Sema |
239 | /// source. |
240 | /// |
241 | /// The external source should append its own tentative definitions to the |
242 | /// given vector of tentative definitions. Note that this routine may be |
243 | /// invoked multiple times; the external source should take care not to |
244 | /// introduce the same declarations repeatedly. |
245 | void ReadTentativeDefinitions(SmallVectorImpl<VarDecl*> &Defs) override; |
246 | |
247 | /// Read the set of unused file-scope declarations known to the |
248 | /// external Sema source. |
249 | /// |
250 | /// The external source should append its own unused, filed-scope to the |
251 | /// given vector of declarations. Note that this routine may be |
252 | /// invoked multiple times; the external source should take care not to |
253 | /// introduce the same declarations repeatedly. |
254 | void ReadUnusedFileScopedDecls( |
255 | SmallVectorImpl<const DeclaratorDecl*> &Decls) override; |
256 | |
257 | /// Read the set of delegating constructors known to the |
258 | /// external Sema source. |
259 | /// |
260 | /// The external source should append its own delegating constructors to the |
261 | /// given vector of declarations. Note that this routine may be |
262 | /// invoked multiple times; the external source should take care not to |
263 | /// introduce the same declarations repeatedly. |
264 | void ReadDelegatingConstructors( |
265 | SmallVectorImpl<CXXConstructorDecl*> &Decls) override; |
266 | |
267 | /// Read the set of ext_vector type declarations known to the |
268 | /// external Sema source. |
269 | /// |
270 | /// The external source should append its own ext_vector type declarations to |
271 | /// the given vector of declarations. Note that this routine may be |
272 | /// invoked multiple times; the external source should take care not to |
273 | /// introduce the same declarations repeatedly. |
274 | void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl*> &Decls) override; |
275 | |
276 | /// Read the set of potentially unused typedefs known to the source. |
277 | /// |
278 | /// The external source should append its own potentially unused local |
279 | /// typedefs to the given vector of declarations. Note that this routine may |
280 | /// be invoked multiple times; the external source should take care not to |
281 | /// introduce the same declarations repeatedly. |
282 | void ReadUnusedLocalTypedefNameCandidates( |
283 | llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) override; |
284 | |
285 | /// Read the set of referenced selectors known to the |
286 | /// external Sema source. |
287 | /// |
288 | /// The external source should append its own referenced selectors to the |
289 | /// given vector of selectors. Note that this routine |
290 | /// may be invoked multiple times; the external source should take care not |
291 | /// to introduce the same selectors repeatedly. |
292 | void ReadReferencedSelectors(SmallVectorImpl<std::pair<Selector, |
293 | SourceLocation> > &Sels) override; |
294 | |
295 | /// Read the set of weak, undeclared identifiers known to the |
296 | /// external Sema source. |
297 | /// |
298 | /// The external source should append its own weak, undeclared identifiers to |
299 | /// the given vector. Note that this routine may be invoked multiple times; |
300 | /// the external source should take care not to introduce the same identifiers |
301 | /// repeatedly. |
302 | void ReadWeakUndeclaredIdentifiers( |
303 | SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI) override; |
304 | |
305 | /// Read the set of used vtables known to the external Sema source. |
306 | /// |
307 | /// The external source should append its own used vtables to the given |
308 | /// vector. Note that this routine may be invoked multiple times; the external |
309 | /// source should take care not to introduce the same vtables repeatedly. |
310 | void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) override; |
311 | |
312 | /// Read the set of pending instantiations known to the external |
313 | /// Sema source. |
314 | /// |
315 | /// The external source should append its own pending instantiations to the |
316 | /// given vector. Note that this routine may be invoked multiple times; the |
317 | /// external source should take care not to introduce the same instantiations |
318 | /// repeatedly. |
319 | void ReadPendingInstantiations( |
320 | SmallVectorImpl<std::pair<ValueDecl*, SourceLocation> >& Pending) override; |
321 | |
322 | /// Read the set of late parsed template functions for this source. |
323 | /// |
324 | /// The external source should insert its own late parsed template functions |
325 | /// into the map. Note that this routine may be invoked multiple times; the |
326 | /// external source should take care not to introduce the same map entries |
327 | /// repeatedly. |
328 | void ReadLateParsedTemplates( |
329 | llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>> |
330 | &LPTMap) override; |
331 | |
332 | /// Read the set of decls to be checked for deferred diags. |
333 | /// |
334 | /// The external source should append its own potentially emitted function |
335 | /// and variable decls which may cause deferred diags. Note that this routine |
336 | /// may be invoked multiple times; the external source should take care not to |
337 | /// introduce the same declarations repeatedly. |
338 | void ReadDeclsToCheckForDeferredDiags( |
339 | llvm::SmallSetVector<Decl *, 4> &Decls) override; |
340 | |
341 | /// \copydoc ExternalSemaSource::CorrectTypo |
342 | /// \note Returns the first nonempty correction. |
343 | TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, |
344 | int LookupKind, Scope *S, CXXScopeSpec *SS, |
345 | CorrectionCandidateCallback &CCC, |
346 | DeclContext *MemberContext, |
347 | bool EnteringContext, |
348 | const ObjCObjectPointerType *OPT) override; |
349 | |
350 | /// Produces a diagnostic note if one of the attached sources |
351 | /// contains a complete definition for \p T. Queries the sources in list |
352 | /// order until the first one claims that a diagnostic was produced. |
353 | /// |
354 | /// \param Loc the location at which a complete type was required but not |
355 | /// provided |
356 | /// |
357 | /// \param T the \c QualType that should have been complete at \p Loc |
358 | /// |
359 | /// \return true if a diagnostic was produced, false otherwise. |
360 | bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc, |
361 | QualType T) override; |
362 | |
363 | // Inform all attached sources that a mangling number was assigned. |
364 | void AssignedLambdaNumbering(const CXXRecordDecl *Lambda) override; |
365 | |
366 | /// LLVM-style RTTI. |
367 | /// \{ |
368 | bool isA(const void *ClassID) const override { |
369 | return ClassID == &ID || ExternalSemaSource::isA(ClassID); |
370 | } |
371 | static bool classof(const ExternalASTSource *S) { return S->isA(ClassID: &ID); } |
372 | /// \} |
373 | }; |
374 | |
375 | } // end namespace clang |
376 | |
377 | #endif |
378 | |