clang  16.0.0git
MultiplexExternalSemaSource.h
Go to the documentation of this file.
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 
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.
39  /// LLVM-style RTTI.
40  static char ID;
41 
42 private:
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  ///
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.
84 
85  /// Resolve the offset of a set of C++ base specifiers in the decl
86  /// stream into an array of specifiers.
88 
89  /// Resolve a handle to a list of ctor initializers into the list of
90  /// initializers themselves.
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  /// 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
218 
219  /// Load the set of used but not defined functions or variables with
220  /// internal linkage, or used but not defined inline functions.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
339  llvm::SmallSetVector<Decl *, 4> &Decls) override;
340 
341  /// \copydoc ExternalSemaSource::CorrectTypo
342  /// \note Returns the first nonempty correction.
344  int LookupKind, Scope *S, CXXScopeSpec *SS,
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.
361  QualType T) override;
362 
363  /// LLVM-style RTTI.
364  /// \{
365  bool isA(const void *ClassID) const override {
366  return ClassID == &ID || ExternalSemaSource::isA(ClassID);
367  }
368  static bool classof(const ExternalASTSource *S) { return S->isA(&ID); }
369  /// \}
370 };
371 
372 } // end namespace clang
373 
374 #endif
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1149
clang::MultiplexExternalSemaSource::FinishedDeserializing
void FinishedDeserializing() override
Notify ExternalASTSource that we finished the deserialization of a decl or type.
Definition: MultiplexExternalSemaSource.cpp:158
Weak.h
clang::MultiplexExternalSemaSource::GetExternalCXXCtorInitializers
CXXCtorInitializer ** GetExternalCXXCtorInitializers(uint64_t Offset) override
Resolve a handle to a list of ctor initializers into the list of initializers themselves.
Definition: MultiplexExternalSemaSource.cpp:94
clang::DeclaratorContext::File
@ File
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1389
clang::TypoCorrection
Simple class containing the result of Sema::CorrectTypo.
Definition: TypoCorrection.h:42
clang::MultiplexExternalSemaSource::ReadTentativeDefinitions
void ReadTentativeDefinitions(SmallVectorImpl< VarDecl * > &Defs) override
Read the set of tentative definitions known to the external Sema source.
Definition: MultiplexExternalSemaSource.cpp:252
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::MultiplexExternalSemaSource::ReadMismatchingDeleteExpressions
void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 >> &Exprs) override
Definition: MultiplexExternalSemaSource.cpp:237
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:737
clang::MultiplexExternalSemaSource::ForgetSema
void ForgetSema() override
Inform the semantic consumer that Sema is no longer available.
Definition: MultiplexExternalSemaSource.cpp:210
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2930
clang::MultiplexExternalSemaSource::ReadKnownNamespaces
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...
Definition: MultiplexExternalSemaSource.cpp:225
clang::MultiplexExternalSemaSource::layoutRecordType
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.
Definition: MultiplexExternalSemaSource.cpp:180
clang::LookupResult
Represents the results of name lookup.
Definition: Lookup.h:46
clang::MultiplexExternalSemaSource::ReadUnusedFileScopedDecls
void ReadUnusedFileScopedDecls(SmallVectorImpl< const DeclaratorDecl * > &Decls) override
Read the set of unused file-scope declarations known to the external Sema source.
Definition: MultiplexExternalSemaSource.cpp:258
clang::MultiplexExternalSemaSource::isA
bool isA(const void *ClassID) const override
LLVM-style RTTI.
Definition: MultiplexExternalSemaSource.h:365
clang::MultiplexExternalSemaSource::completeVisibleDeclsMap
void completeVisibleDeclsMap(const DeclContext *DC) override
Ensures that the table of all visible declarations inside this context is up to date.
Definition: MultiplexExternalSemaSource.cpp:118
clang::CXXScopeSpec
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:65
clang::MultiplexExternalSemaSource::getModule
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
Definition: MultiplexExternalSemaSource.cpp:173
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:144
clang::MultiplexExternalSemaSource::AddSource
void AddSource(ExternalSemaSource *Source)
Appends new source to the source list.
Definition: MultiplexExternalSemaSource.cpp:40
clang::MultiplexExternalSemaSource::CompleteType
void CompleteType(TagDecl *Tag) override
Gives the external AST source an opportunity to complete an incomplete type.
Definition: MultiplexExternalSemaSource.cpp:138
Offset
unsigned Offset
Definition: Format.cpp:2717
clang::Decl::Kind
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:86
clang::MultiplexExternalSemaSource::ReadComments
void ReadComments() override
Loads comment ranges.
Definition: MultiplexExternalSemaSource.cpp:148
clang::MultiplexExternalSemaSource::StartTranslationUnit
void StartTranslationUnit(ASTConsumer *Consumer) override
Function that will be invoked when we begin parsing a new translation unit involving this external AS...
Definition: MultiplexExternalSemaSource.cpp:163
clang::MultiplexExternalSemaSource::CompleteRedeclChain
void CompleteRedeclChain(const Decl *D) override
Complete the redeclaration chain if it's been extended since the previous generation of the AST sourc...
Definition: MultiplexExternalSemaSource.cpp:56
clang::MultiplexExternalSemaSource::GetExternalSelector
Selector GetExternalSelector(uint32_t ID) override
Resolve a selector ID into a selector.
Definition: MultiplexExternalSemaSource.cpp:61
clang::Module
Describes a module or submodule.
Definition: Module.h:98
clang::MultiplexExternalSemaSource::FindExternalVisibleDeclsByName
bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) override
Find all declarations with the given name in the given context.
Definition: MultiplexExternalSemaSource.cpp:111
clang::MultiplexExternalSemaSource::MultiplexExternalSemaSource
MultiplexExternalSemaSource(ExternalSemaSource *S1, ExternalSemaSource *S2)
Constructs a new multiplexing external sema source and appends the given element to it.
Definition: MultiplexExternalSemaSource.cpp:22
hlsl::uint64_t
unsigned long uint64_t
Definition: hlsl_basic_types.h:25
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::MultiplexExternalSemaSource::ReadLateParsedTemplates
void ReadLateParsedTemplates(llvm::MapVector< const FunctionDecl *, std::unique_ptr< LateParsedTemplate >> &LPTMap) override
Read the set of late parsed template functions for this source.
Definition: MultiplexExternalSemaSource.cpp:313
clang::ExternalASTSource::MemoryBufferSizes
Definition: ExternalASTSource.h:278
clang::ASTConsumer
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.
Definition: ASTConsumer.h:33
clang::ExternalSemaSource
An abstract interface that should be implemented by external AST sources that also provide informatio...
Definition: ExternalSemaSource.h:50
clang::MultiplexExternalSemaSource
An abstract interface that should be implemented by external AST sources that also provide informatio...
Definition: MultiplexExternalSemaSource.h:38
clang::MultiplexExternalSemaSource::InitializeSema
void InitializeSema(Sema &S) override
Initialize the semantic source with the Sema instance being used to perform semantic analysis on the ...
Definition: MultiplexExternalSemaSource.cpp:205
clang::MultiplexExternalSemaSource::GetExternalDeclStmt
Stmt * GetExternalDeclStmt(uint64_t Offset) override
Resolve the offset of a statement in the decl stream into a statement.
Definition: MultiplexExternalSemaSource.cpp:78
clang::MultiplexExternalSemaSource::MaybeDiagnoseMissingCompleteType
bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc, QualType T) override
Produces a diagnostic note if one of the attached sources contains a complete definition for T.
Definition: MultiplexExternalSemaSource.cpp:336
clang::TagDecl
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3423
clang::MultiplexExternalSemaSource::ReadDeclsToCheckForDeferredDiags
void ReadDeclsToCheckForDeferredDiags(llvm::SmallSetVector< Decl *, 4 > &Decls) override
Read the set of decls to be checked for deferred diags.
Definition: MultiplexExternalSemaSource.cpp:276
clang::MultiplexExternalSemaSource::ReadDelegatingConstructors
void ReadDelegatingConstructors(SmallVectorImpl< CXXConstructorDecl * > &Decls) override
Read the set of delegating constructors known to the external Sema source.
Definition: MultiplexExternalSemaSource.cpp:264
clang::MultiplexExternalSemaSource::hasExternalDefinitions
ExtKind hasExternalDefinitions(const Decl *D) override
Definition: MultiplexExternalSemaSource.cpp:102
clang::MultiplexExternalSemaSource::ReadMethodPool
void ReadMethodPool(Selector Sel) override
Load the contents of the global method pool for a given selector.
Definition: MultiplexExternalSemaSource.cpp:215
clang::MultiplexExternalSemaSource::CorrectTypo
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...
Definition: MultiplexExternalSemaSource.cpp:320
clang::ExternalASTSource::getMemoryBufferSizes
MemoryBufferSizes getMemoryBufferSizes() const
Return the amount of memory used by memory buffers, breaking down by heap-backed versus mmap'ed memor...
Definition: ExternalASTSource.h:288
clang::ObjCObjectPointerType
Represents a pointer to an Objective C object.
Definition: Type.h:6270
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
clang::MultiplexExternalSemaSource::StartedDeserializing
void StartedDeserializing() override
Notify ExternalASTSource that we started deserialization of a decl or type so until FinishedDeseriali...
Definition: MultiplexExternalSemaSource.cpp:153
ExternalSemaSource.h
clang::MultiplexExternalSemaSource::FindExternalLexicalDecls
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...
Definition: MultiplexExternalSemaSource.cpp:123
clang::ExternalASTSource::ExtKind
ExtKind
Definition: ExternalASTSource.h:165
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::MultiplexExternalSemaSource::LookupUnqualified
bool LookupUnqualified(LookupResult &R, Scope *S) override
Do last resort, unqualified lookup on a LookupResult that Sema cannot find.
Definition: MultiplexExternalSemaSource.cpp:245
clang::MultiplexExternalSemaSource::ReadUsedVTables
void ReadUsedVTables(SmallVectorImpl< ExternalVTableUse > &VTables) override
Read the set of used vtables known to the external Sema source.
Definition: MultiplexExternalSemaSource.cpp:300
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:358
clang::MultiplexExternalSemaSource::classof
static bool classof(const ExternalASTSource *S)
Definition: MultiplexExternalSemaSource.h:368
clang::MultiplexExternalSemaSource::ReadUnusedLocalTypedefNameCandidates
void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls) override
Read the set of potentially unused typedefs known to the source.
Definition: MultiplexExternalSemaSource.cpp:282
clang::MultiplexExternalSemaSource::FindFileRegionDecls
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.
Definition: MultiplexExternalSemaSource.cpp:130
clang::MultiplexExternalSemaSource::ReadReferencedSelectors
void ReadReferencedSelectors(SmallVectorImpl< std::pair< Selector, SourceLocation > > &Sels) override
Read the set of referenced selectors known to the external Sema source.
Definition: MultiplexExternalSemaSource.cpp:288
clang
Definition: CalledOnceCheck.h:17
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:759
clang::MultiplexExternalSemaSource::~MultiplexExternalSemaSource
~MultiplexExternalSemaSource() override
Definition: MultiplexExternalSemaSource.cpp:31
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:71
clang::MultiplexExternalSemaSource::GetExternalCXXBaseSpecifiers
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.
Definition: MultiplexExternalSemaSource.cpp:85
clang::MultiplexExternalSemaSource::ReadWeakUndeclaredIdentifiers
void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WI) override
Read the set of weak, undeclared identifiers known to the external Sema source.
Definition: MultiplexExternalSemaSource.cpp:294
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:38
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::CorrectionCandidateCallback
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
Definition: TypoCorrection.h:281
clang::MultiplexExternalSemaSource::ReadExtVectorDecls
void ReadExtVectorDecls(SmallVectorImpl< TypedefNameDecl * > &Decls) override
Read the set of ext_vector type declarations known to the external Sema source.
Definition: MultiplexExternalSemaSource.cpp:270
clang::MultiplexExternalSemaSource::GetExternalDecl
Decl * GetExternalDecl(uint32_t ID) override
Resolve a declaration ID into a declaration, potentially building a new declaration.
Definition: MultiplexExternalSemaSource.cpp:49
clang::CharUnits
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
llvm::SmallVectorImpl
Definition: Randstruct.h:18
clang::ExternalSemaSource::isA
bool isA(const void *ClassID) const override
LLVM-style RTTI.
Definition: ExternalSemaSource.h:235
llvm::SmallSetVector
Definition: ExternalSemaSource.h:23
clang::CXXCtorInitializer
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2207
clang::ExternalASTSource
Abstract interface for external sources of AST nodes.
Definition: ExternalASTSource.h:60
clang::MultiplexExternalSemaSource::updateOutOfDateSelector
void updateOutOfDateSelector(Selector Sel) override
Load the contents of the global method pool for a given selector if necessary.
Definition: MultiplexExternalSemaSource.cpp:220
clang::DeclarationNameInfo
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Definition: DeclarationName.h:767
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1904
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3983
clang::MultiplexExternalSemaSource::GetNumExternalSelectors
uint32_t GetNumExternalSelectors() override
Returns the number of selectors known to the external AST source.
Definition: MultiplexExternalSemaSource.cpp:71
clang::MultiplexExternalSemaSource::PrintStats
void PrintStats() override
Print any statistics that have been gathered regarding the external AST source.
Definition: MultiplexExternalSemaSource.cpp:168
clang::MultiplexExternalSemaSource::ReadPendingInstantiations
void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation > > &Pending) override
Read the set of pending instantiations known to the external Sema source.
Definition: MultiplexExternalSemaSource.cpp:306
clang::MultiplexExternalSemaSource::ReadUndefinedButUsed
void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined) override
Load the set of used but not defined functions or variables with internal linkage,...
Definition: MultiplexExternalSemaSource.cpp:231