Coverage Report

Created: 2020-09-15 12:33

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Sema/ExternalSemaSource.h
Line
Count
Source (jump to first uncovered line)
1
//===--- ExternalSemaSource.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 the ExternalSemaSource interface.
10
//
11
//===----------------------------------------------------------------------===//
12
#ifndef LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H
13
#define LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H
14
15
#include "clang/AST/ExternalASTSource.h"
16
#include "clang/AST/Type.h"
17
#include "clang/Sema/TypoCorrection.h"
18
#include "clang/Sema/Weak.h"
19
#include "llvm/ADT/MapVector.h"
20
#include <utility>
21
22
namespace llvm {
23
template <class T, unsigned n> class SmallSetVector;
24
}
25
26
namespace clang {
27
28
class CXXConstructorDecl;
29
class CXXDeleteExpr;
30
class CXXRecordDecl;
31
class DeclaratorDecl;
32
class LookupResult;
33
struct ObjCMethodList;
34
class Scope;
35
class Sema;
36
class TypedefNameDecl;
37
class ValueDecl;
38
class VarDecl;
39
struct LateParsedTemplate;
40
41
/// A simple structure that captures a vtable use for the purposes of
42
/// the \c ExternalSemaSource.
43
struct ExternalVTableUse {
44
  CXXRecordDecl *Record;
45
  SourceLocation Location;
46
  bool DefinitionRequired;
47
};
48
49
/// An abstract interface that should be implemented by
50
/// external AST sources that also provide information for semantic
51
/// analysis.
52
class ExternalSemaSource : public ExternalASTSource {
53
  /// LLVM-style RTTI.
54
  static char ID;
55
56
public:
57
14.6k
  ExternalSemaSource() = default;
58
59
  ~ExternalSemaSource() override;
60
61
  /// Initialize the semantic source with the Sema instance
62
  /// being used to perform semantic analysis on the abstract syntax
63
  /// tree.
64
1.12k
  virtual void InitializeSema(Sema &S) {}
65
66
  /// Inform the semantic consumer that Sema is no longer available.
67
1.11k
  virtual void ForgetSema() {}
68
69
  /// Load the contents of the global method pool for a given
70
  /// selector.
71
  virtual void ReadMethodPool(Selector Sel);
72
73
  /// Load the contents of the global method pool for a given
74
  /// selector if necessary.
75
  virtual void updateOutOfDateSelector(Selector Sel);
76
77
  /// Load the set of namespaces that are known to the external source,
78
  /// which will be used during typo correction.
79
  virtual void ReadKnownNamespaces(
80
                           SmallVectorImpl<NamespaceDecl *> &Namespaces);
81
82
  /// Load the set of used but not defined functions or variables with
83
  /// internal linkage, or used but not defined internal functions.
84
  virtual void
85
  ReadUndefinedButUsed(llvm::MapVector<NamedDecl *, SourceLocation> &Undefined);
86
87
  virtual void ReadMismatchingDeleteExpressions(llvm::MapVector<
88
      FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &);
89
90
  /// Do last resort, unqualified lookup on a LookupResult that
91
  /// Sema cannot find.
92
  ///
93
  /// \param R a LookupResult that is being recovered.
94
  ///
95
  /// \param S the Scope of the identifier occurrence.
96
  ///
97
  /// \return true to tell Sema to recover using the LookupResult.
98
1.82M
  virtual bool LookupUnqualified(LookupResult &R, Scope *S) { return false; }
99
100
  /// Read the set of tentative definitions known to the external Sema
101
  /// source.
102
  ///
103
  /// The external source should append its own tentative definitions to the
104
  /// given vector of tentative definitions. Note that this routine may be
105
  /// invoked multiple times; the external source should take care not to
106
  /// introduce the same declarations repeatedly.
107
  virtual void ReadTentativeDefinitions(
108
10
                                  SmallVectorImpl<VarDecl *> &TentativeDefs) {}
109
110
  /// Read the set of unused file-scope declarations known to the
111
  /// external Sema source.
112
  ///
113
  /// The external source should append its own unused, filed-scope to the
114
  /// given vector of declarations. Note that this routine may be
115
  /// invoked multiple times; the external source should take care not to
116
  /// introduce the same declarations repeatedly.
117
  virtual void ReadUnusedFileScopedDecls(
118
1
                 SmallVectorImpl<const DeclaratorDecl *> &Decls) {}
119
120
  /// Read the set of delegating constructors known to the
121
  /// external Sema source.
122
  ///
123
  /// The external source should append its own delegating constructors to the
124
  /// given vector of declarations. Note that this routine may be
125
  /// invoked multiple times; the external source should take care not to
126
  /// introduce the same declarations repeatedly.
127
  virtual void ReadDelegatingConstructors(
128
9
                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {}
129
130
  /// Read the set of ext_vector type declarations known to the
131
  /// external Sema source.
132
  ///
133
  /// The external source should append its own ext_vector type declarations to
134
  /// the given vector of declarations. Note that this routine may be
135
  /// invoked multiple times; the external source should take care not to
136
  /// introduce the same declarations repeatedly.
137
0
  virtual void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {}
138
139
  /// Read the set of potentially unused typedefs known to the source.
140
  ///
141
  /// The external source should append its own potentially unused local
142
  /// typedefs to the given vector of declarations. Note that this routine may
143
  /// be invoked multiple times; the external source should take care not to
144
  /// introduce the same declarations repeatedly.
145
  virtual void ReadUnusedLocalTypedefNameCandidates(
146
1
      llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {}
147
148
  /// Read the set of referenced selectors known to the
149
  /// external Sema source.
150
  ///
151
  /// The external source should append its own referenced selectors to the
152
  /// given vector of selectors. Note that this routine
153
  /// may be invoked multiple times; the external source should take care not
154
  /// to introduce the same selectors repeatedly.
155
  virtual void ReadReferencedSelectors(
156
10
                 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {}
157
158
  /// Read the set of weak, undeclared identifiers known to the
159
  /// external Sema source.
160
  ///
161
  /// The external source should append its own weak, undeclared identifiers to
162
  /// the given vector. Note that this routine may be invoked multiple times;
163
  /// the external source should take care not to introduce the same identifiers
164
  /// repeatedly.
165
  virtual void ReadWeakUndeclaredIdentifiers(
166
17
                 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WI) {}
167
168
  /// Read the set of used vtables known to the external Sema source.
169
  ///
170
  /// The external source should append its own used vtables to the given
171
  /// vector. Note that this routine may be invoked multiple times; the external
172
  /// source should take care not to introduce the same vtables repeatedly.
173
10
  virtual void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {}
174
175
  /// Read the set of pending instantiations known to the external
176
  /// Sema source.
177
  ///
178
  /// The external source should append its own pending instantiations to the
179
  /// given vector. Note that this routine may be invoked multiple times; the
180
  /// external source should take care not to introduce the same instantiations
181
  /// repeatedly.
182
  virtual void ReadPendingInstantiations(
183
                 SmallVectorImpl<std::pair<ValueDecl *,
184
10
                                           SourceLocation> > &Pending) {}
185
186
  /// Read the set of late parsed template functions for this source.
187
  ///
188
  /// The external source should insert its own late parsed template functions
189
  /// into the map. Note that this routine may be invoked multiple times; the
190
  /// external source should take care not to introduce the same map entries
191
  /// repeatedly.
192
  virtual void ReadLateParsedTemplates(
193
      llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
194
0
          &LPTMap) {}
195
196
  /// Read the set of decls to be checked for deferred diags.
197
  ///
198
  /// The external source should append its own potentially emitted function
199
  /// and variable decls which may cause deferred diags. Note that this routine
200
  /// may be invoked multiple times; the external source should take care not to
201
  /// introduce the same declarations repeatedly.
202
  virtual void ReadDeclsToCheckForDeferredDiags(
203
10
      llvm::SmallVector<Decl *, 4> &Decls) {}
204
205
  /// \copydoc Sema::CorrectTypo
206
  /// \note LookupKind must correspond to a valid Sema::LookupNameKind
207
  ///
208
  /// ExternalSemaSource::CorrectTypo is always given the first chance to
209
  /// correct a typo (really, to offer suggestions to repair a failed lookup).
210
  /// It will even be called when SpellChecking is turned off or after a
211
  /// fatal error has already been detected.
212
  virtual TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
213
                                     int LookupKind, Scope *S, CXXScopeSpec *SS,
214
                                     CorrectionCandidateCallback &CCC,
215
                                     DeclContext *MemberContext,
216
                                     bool EnteringContext,
217
3.32k
                                     const ObjCObjectPointerType *OPT) {
218
3.32k
    return TypoCorrection();
219
3.32k
  }
220
221
  /// Produces a diagnostic note if the external source contains a
222
  /// complete definition for \p T.
223
  ///
224
  /// \param Loc the location at which a complete type was required but not
225
  /// provided
226
  ///
227
  /// \param T the \c QualType that should have been complete at \p Loc
228
  ///
229
  /// \return true if a diagnostic was produced, false otherwise.
230
  virtual bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc,
231
28
                                                QualType T) {
232
28
    return false;
233
28
  }
234
235
  /// LLVM-style RTTI.
236
  /// \{
237
160k
  bool isA(const void *ClassID) const override {
238
160k
    return ClassID == &ID || 
ExternalASTSource::isA(ClassID)114k
;
239
160k
  }
240
66.7k
  static bool classof(const ExternalASTSource *S) { return S->isA(&ID); }
241
  /// \}
242
};
243
244
} // end namespace clang
245
246
#endif