clang  8.0.0svn
MultiplexExternalSemaSource.h
Go to the documentation of this file.
1 //===--- MultiplexExternalSemaSource.h - External Sema Interface-*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines ExternalSemaSource interface, dispatching to all clients
11 //
12 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_CLANG_SEMA_MULTIPLEXEXTERNALSEMASOURCE_H
14 #define LLVM_CLANG_SEMA_MULTIPLEXEXTERNALSEMASOURCE_H
15 
17 #include "clang/Sema/Weak.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include <utility>
20 
21 namespace clang {
22 
23  class CXXConstructorDecl;
24  class CXXRecordDecl;
25  class DeclaratorDecl;
26  struct ExternalVTableUse;
27  class LookupResult;
28  class NamespaceDecl;
29  class Scope;
30  class Sema;
31  class TypedefNameDecl;
32  class ValueDecl;
33  class VarDecl;
34 
35 
36 /// An abstract interface that should be implemented by
37 /// external AST sources that also provide information for semantic
38 /// analysis.
40 
41 private:
42  SmallVector<ExternalSemaSource *, 2> Sources; // doesn't own them.
43 
44 public:
45 
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  ///
53 
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.
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
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  bool DeclIsFromPCHWithObjectFile(const Decl *D) override;
156 
157  /// Perform layout on the given record.
158  ///
159  /// This routine allows the external AST source to provide an specific
160  /// layout for a record, overriding the layout that would normally be
161  /// constructed. It is intended for clients who receive specific layout
162  /// details rather than source code (such as LLDB). The client is expected
163  /// to fill in the field offsets, base offsets, virtual base offsets, and
164  /// complete object size.
165  ///
166  /// \param Record The record whose layout is being requested.
167  ///
168  /// \param Size The final size of the record, in bits.
169  ///
170  /// \param Alignment The final alignment of the record, in bits.
171  ///
172  /// \param FieldOffsets The offset of each of the fields within the record,
173  /// expressed in bits. All of the fields must be provided with offsets.
174  ///
175  /// \param BaseOffsets The offset of each of the direct, non-virtual base
176  /// classes. If any bases are not given offsets, the bases will be laid
177  /// out according to the ABI.
178  ///
179  /// \param VirtualBaseOffsets The offset of each of the virtual base classes
180  /// (either direct or not). If any bases are not given offsets, the bases will
181  /// be laid out according to the ABI.
182  ///
183  /// \returns true if the record layout was provided, false otherwise.
184  bool
185  layoutRecordType(const RecordDecl *Record,
186  uint64_t &Size, uint64_t &Alignment,
187  llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
188  llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
189  llvm::DenseMap<const CXXRecordDecl *,
190  CharUnits> &VirtualBaseOffsets) override;
191 
192  /// Return the amount of memory used by memory buffers, breaking down
193  /// by heap-backed versus mmap'ed memory.
194  void getMemoryBufferSizes(MemoryBufferSizes &sizes) const override;
195 
196  //===--------------------------------------------------------------------===//
197  // ExternalSemaSource.
198  //===--------------------------------------------------------------------===//
199 
200  /// Initialize the semantic source with the Sema instance
201  /// being used to perform semantic analysis on the abstract syntax
202  /// tree.
203  void InitializeSema(Sema &S) override;
204 
205  /// Inform the semantic consumer that Sema is no longer available.
206  void ForgetSema() override;
207 
208  /// Load the contents of the global method pool for a given
209  /// selector.
210  void ReadMethodPool(Selector Sel) override;
211 
212  /// Load the contents of the global method pool for a given
213  /// selector if necessary.
214  void updateOutOfDateSelector(Selector Sel) override;
215 
216  /// Load the set of namespaces that are known to the external source,
217  /// which will be used during typo correction.
218  void
220 
221  /// Load the set of used but not defined functions or variables with
222  /// internal linkage, or used but not defined inline functions.
224  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) override;
225 
226  void ReadMismatchingDeleteExpressions(llvm::MapVector<
227  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
228  Exprs) override;
229 
230  /// Do last resort, unqualified lookup on a LookupResult that
231  /// Sema cannot find.
232  ///
233  /// \param R a LookupResult that is being recovered.
234  ///
235  /// \param S the Scope of the identifier occurrence.
236  ///
237  /// \return true to tell Sema to recover using the LookupResult.
238  bool LookupUnqualified(LookupResult &R, Scope *S) override;
239 
240  /// Read the set of tentative definitions known to the external Sema
241  /// source.
242  ///
243  /// The external source should append its own tentative definitions to the
244  /// given vector of tentative definitions. Note that this routine may be
245  /// invoked multiple times; the external source should take care not to
246  /// introduce the same declarations repeatedly.
248 
249  /// Read the set of unused file-scope declarations known to the
250  /// external Sema source.
251  ///
252  /// The external source should append its own unused, filed-scope to the
253  /// given vector of declarations. Note that this routine may be
254  /// invoked multiple times; the external source should take care not to
255  /// introduce the same declarations repeatedly.
258 
259  /// Read the set of delegating constructors known to the
260  /// external Sema source.
261  ///
262  /// The external source should append its own delegating constructors to the
263  /// given vector of declarations. Note that this routine may be
264  /// invoked multiple times; the external source should take care not to
265  /// introduce the same declarations repeatedly.
267  SmallVectorImpl<CXXConstructorDecl*> &Decls) override;
268 
269  /// Read the set of ext_vector type declarations known to the
270  /// external Sema source.
271  ///
272  /// The external source should append its own ext_vector type declarations to
273  /// the given vector of declarations. Note that this routine may be
274  /// invoked multiple times; the external source should take care not to
275  /// introduce the same declarations repeatedly.
277 
278  /// Read the set of potentially unused typedefs known to the source.
279  ///
280  /// The external source should append its own potentially unused local
281  /// typedefs to the given vector of declarations. Note that this routine may
282  /// be invoked multiple times; the external source should take care not to
283  /// introduce the same declarations repeatedly.
286 
287  /// Read the set of referenced selectors known to the
288  /// external Sema source.
289  ///
290  /// The external source should append its own referenced selectors to the
291  /// given vector of selectors. Note that this routine
292  /// may be invoked multiple times; the external source should take care not
293  /// to introduce the same selectors repeatedly.
295  SourceLocation> > &Sels) override;
296 
297  /// Read the set of weak, undeclared identifiers known to the
298  /// external Sema source.
299  ///
300  /// The external source should append its own weak, undeclared identifiers to
301  /// the given vector. Note that this routine may be invoked multiple times;
302  /// the external source should take care not to introduce the same identifiers
303  /// repeatedly.
305  SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI) override;
306 
307  /// Read the set of used vtables known to the external Sema source.
308  ///
309  /// The external source should append its own used vtables to the given
310  /// vector. Note that this routine may be invoked multiple times; the external
311  /// source should take care not to introduce the same vtables repeatedly.
312  void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) override;
313 
314  /// Read the set of pending instantiations known to the external
315  /// Sema source.
316  ///
317  /// The external source should append its own pending instantiations to the
318  /// given vector. Note that this routine may be invoked multiple times; the
319  /// external source should take care not to introduce the same instantiations
320  /// repeatedly.
322  SmallVectorImpl<std::pair<ValueDecl*, SourceLocation> >& Pending) override;
323 
324  /// Read the set of late parsed template functions for this source.
325  ///
326  /// The external source should insert its own late parsed template functions
327  /// into the map. Note that this routine may be invoked multiple times; the
328  /// external source should take care not to introduce the same map entries
329  /// repeatedly.
331  llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
332  &LPTMap) override;
333 
334  /// \copydoc ExternalSemaSource::CorrectTypo
335  /// \note Returns the first nonempty correction.
337  int LookupKind, Scope *S, CXXScopeSpec *SS,
340  bool EnteringContext,
341  const ObjCObjectPointerType *OPT) override;
342 
343  /// Produces a diagnostic note if one of the attached sources
344  /// contains a complete definition for \p T. Queries the sources in list
345  /// order until the first one claims that a diagnostic was produced.
346  ///
347  /// \param Loc the location at which a complete type was required but not
348  /// provided
349  ///
350  /// \param T the \c QualType that should have been complete at \p Loc
351  ///
352  /// \return true if a diagnostic was produced, false otherwise.
354  QualType T) override;
355 
356  // isa/cast/dyn_cast support
357  static bool classof(const MultiplexExternalSemaSource*) { return true; }
358  //static bool classof(const ExternalSemaSource*) { return true; }
359 };
360 
361 } // end namespace clang
362 
363 #endif
Represents a function declaration or definition.
Definition: Decl.h:1717
bool DeclIsFromPCHWithObjectFile(const Decl *D) override
Determine whether D comes from a PCH which was built with a corresponding object file.
Smart pointer class that efficiently represents Objective-C method names.
A (possibly-)qualified type.
Definition: Type.h:642
Simple class containing the result of Sema::CorrectTypo.
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:34
void completeVisibleDeclsMap(const DeclContext *DC) override
Ensures that the table of all visible declarations inside this context is up to date.
Stmt - This represents one statement.
Definition: Stmt.h:66
void StartTranslationUnit(ASTConsumer *Consumer) override
Function that will be invoked when we begin parsing a new translation unit involving this external AS...
void StartedDeserializing() override
Notify ExternalASTSource that we started deserialization of a decl or type so until FinishedDeseriali...
void ReadMethodPool(Selector Sel) override
Load the contents of the global method pool for a given selector.
void FindExternalLexicalDecls(const DeclContext *DC, llvm::function_ref< bool(Decl::Kind)> IsKindWeWant, SmallVectorImpl< Decl *> &Result) override
Finds all declarations lexically contained within the given DeclContext, after applying an optional f...
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
void CompleteRedeclChain(const Decl *D) override
Complete the redeclaration chain if it&#39;s been extended since the previous generation of the AST sourc...
bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) override
Find all declarations with the given name in the given context.
Represents a struct/union/class.
Definition: Decl.h:3570
bool LookupUnqualified(LookupResult &R, Scope *S) override
Do last resort, unqualified lookup on a LookupResult that Sema cannot find.
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
void InitializeSema(Sema &S) override
Initialize the semantic source with the Sema instance being used to perform semantic analysis on the ...
Represents a member of a struct/union/class.
Definition: Decl.h:2556
Describes a module or submodule.
Definition: Module.h:65
void ReadKnownNamespaces(SmallVectorImpl< NamespaceDecl *> &Namespaces) override
Load the set of namespaces that are known to the external source, which will be used during typo corr...
void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WI) override
Read the set of weak, undeclared identifiers known to the external Sema source.
Represents the results of name lookup.
Definition: Lookup.h:47
Stmt * GetExternalDeclStmt(uint64_t Offset) override
Resolve the offset of a statement in the decl stream into a statement.
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
uint32_t Offset
Definition: CacheTokens.cpp:43
bool layoutRecordType(const RecordDecl *Record, uint64_t &Size, uint64_t &Alignment, llvm::DenseMap< const FieldDecl *, uint64_t > &FieldOffsets, llvm::DenseMap< const CXXRecordDecl *, CharUnits > &BaseOffsets, llvm::DenseMap< const CXXRecordDecl *, CharUnits > &VirtualBaseOffsets) override
Perform layout on the given record.
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
uint32_t GetNumExternalSelectors() override
Returns the number of selectors known to the external AST source.
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
Decl * GetExternalDecl(uint32_t ID) override
Resolve a declaration ID into a declaration, potentially building a new declaration.
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, int LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, DeclContext *MemberContext, bool EnteringContext, const ObjCObjectPointerType *OPT) override
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
Represents an ObjC class declaration.
Definition: DeclObjC.h:1164
ExtKind hasExternalDefinitions(const Decl *D) override
void FindFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl< Decl *> &Decls) override
Get the decls that are contained in a file in the Offset/Length range.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
void ReadExtVectorDecls(SmallVectorImpl< TypedefNameDecl *> &Decls) override
Read the set of ext_vector type declarations known to the external Sema source.
void ForgetSema() override
Inform the semantic consumer that Sema is no longer available.
An abstract interface that should be implemented by external AST sources that also provide informatio...
void updateOutOfDateSelector(Selector Sel) override
Load the contents of the global method pool for a given selector if necessary.
void FinishedDeserializing() override
Notify ExternalASTSource that we finished the deserialization of a decl or type.
void CompleteType(TagDecl *Tag) override
Gives the external AST source an opportunity to complete an incomplete type.
void PrintStats() override
Print any statistics that have been gathered regarding the external AST source.
void ReadUsedVTables(SmallVectorImpl< ExternalVTableUse > &VTables) override
Read the set of used vtables known to the external Sema source.
CXXCtorInitializer ** GetExternalCXXCtorInitializers(uint64_t Offset) override
Resolve a handle to a list of ctor initializers into the list of initializers themselves.
void ReadTentativeDefinitions(SmallVectorImpl< VarDecl *> &Defs) override
Read the set of tentative definitions known to the external Sema source.
static bool classof(const MultiplexExternalSemaSource *)
The result type of a method or function.
MemoryBufferSizes getMemoryBufferSizes() const
Return the amount of memory used by memory buffers, breaking down by heap-backed versus mmap&#39;ed memor...
void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation > > &Pending) override
Read the set of pending instantiations known to the external Sema source.
void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 >> &Exprs) override
An abstract interface that should be implemented by external AST sources that also provide informatio...
void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls) override
Read the set of potentially unused typedefs known to the source.
Encodes a location in the source.
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3041
void ReadDelegatingConstructors(SmallVectorImpl< CXXConstructorDecl *> &Decls) override
Read the set of delegating constructors known to the external Sema source.
void ReadReferencedSelectors(SmallVectorImpl< std::pair< Selector, SourceLocation > > &Sels) override
Read the set of referenced selectors known to the external Sema source.
void ReadUnusedFileScopedDecls(SmallVectorImpl< const DeclaratorDecl *> &Decls) override
Read the set of unused file-scope declarations known to the external Sema source. ...
CXXBaseSpecifier * GetExternalCXXBaseSpecifiers(uint64_t Offset) override
Resolve the offset of a set of C++ base specifiers in the decl stream into an array of specifiers...
MultiplexExternalSemaSource(ExternalSemaSource &s1, ExternalSemaSource &s2)
Constructs a new multiplexing external sema source and appends the given element to it...
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Dataflow Directional Tag Classes.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
The name of a declaration.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined) override
Load the set of used but not defined functions or variables with internal linkage, or used but not defined inline functions.
void ReadLateParsedTemplates(llvm::MapVector< const FunctionDecl *, std::unique_ptr< LateParsedTemplate >> &LPTMap) override
Read the set of late parsed template functions for this source.
Represents a pointer to an Objective C object.
Definition: Type.h:5675
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2255
void addSource(ExternalSemaSource &source)
Appends new source to the source list.
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
void ReadComments() override
Loads comment ranges.
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
Selector GetExternalSelector(uint32_t ID) override
Resolve a selector ID into a selector.
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:90
bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc, QualType T) override
Produces a diagnostic note if one of the attached sources contains a complete definition for T...