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