Coverage Report

Created: 2018-09-21 05:35

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Sema/MultiplexExternalSemaSource.h
Line
Count
Source (jump to first uncovered line)
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
16
#include "clang/Sema/ExternalSemaSource.h"
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.
39
class MultiplexExternalSemaSource : public ExternalSemaSource {
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
  ///
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
  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
219
  ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl*> &Namespaces) override;
220
221
  /// Load the set of used but not defined functions or variables with
222
  /// internal linkage, or used but not defined inline functions.
223
  void ReadUndefinedButUsed(
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.
247
  void ReadTentativeDefinitions(SmallVectorImpl<VarDecl*> &Defs) override;
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.
256
  void ReadUnusedFileScopedDecls(
257
                        SmallVectorImpl<const DeclaratorDecl*> &Decls) override;
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.
266
  void ReadDelegatingConstructors(
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.
276
  void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl*> &Decls) override;
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.
284
  void ReadUnusedLocalTypedefNameCandidates(
285
      llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) override;
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.
294
  void ReadReferencedSelectors(SmallVectorImpl<std::pair<Selector,
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.
304
  void ReadWeakUndeclaredIdentifiers(
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.
321
  void ReadPendingInstantiations(
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.
330
  void ReadLateParsedTemplates(
331
      llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
332
          &LPTMap) override;
333
334
  /// \copydoc ExternalSemaSource::CorrectTypo
335
  /// \note Returns the first nonempty correction.
336
  TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
337
                             int LookupKind, Scope *S, CXXScopeSpec *SS,
338
                             CorrectionCandidateCallback &CCC,
339
                             DeclContext *MemberContext,
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.
353
  bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc,
354
                                        QualType T) override;
355
356
  // isa/cast/dyn_cast support
357
0
  static bool classof(const MultiplexExternalSemaSource*) { return true; }
358
  //static bool classof(const ExternalSemaSource*) { return true; }
359
};
360
361
} // end namespace clang
362
363
#endif