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
20namespace 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.
38class MultiplexExternalSemaSource : public ExternalSemaSource {
39 /// LLVM-style RTTI.
40 static char ID;
41
42private:
43 SmallVector<ExternalSemaSource *, 2> Sources;
44
45public:
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 ReadComments() 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

source code of clang/include/clang/Sema/MultiplexExternalSemaSource.h