Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/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
public:
54
7.44k
  ExternalSemaSource() {
55
7.44k
    ExternalASTSource::SemaSource = true;
56
7.44k
  }
57
58
  ~ExternalSemaSource() override;
59
60
  /// Initialize the semantic source with the Sema instance
61
  /// being used to perform semantic analysis on the abstract syntax
62
  /// tree.
63
32
  virtual void InitializeSema(Sema &S) {}
64
65
  /// Inform the semantic consumer that Sema is no longer available.
66
27
  virtual void ForgetSema() {}
67
68
  /// Load the contents of the global method pool for a given
69
  /// selector.
70
  virtual void ReadMethodPool(Selector Sel);
71
72
  /// Load the contents of the global method pool for a given
73
  /// selector if necessary.
74
  virtual void updateOutOfDateSelector(Selector Sel);
75
76
  /// Load the set of namespaces that are known to the external source,
77
  /// which will be used during typo correction.
78
  virtual void ReadKnownNamespaces(
79
                           SmallVectorImpl<NamespaceDecl *> &Namespaces);
80
81
  /// Load the set of used but not defined functions or variables with
82
  /// internal linkage, or used but not defined internal functions.
83
  virtual void
84
  ReadUndefinedButUsed(llvm::MapVector<NamedDecl *, SourceLocation> &Undefined);
85
86
  virtual void ReadMismatchingDeleteExpressions(llvm::MapVector<
87
      FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &);
88
89
  /// Do last resort, unqualified lookup on a LookupResult that
90
  /// Sema cannot find.
91
  ///
92
  /// \param R a LookupResult that is being recovered.
93
  ///
94
  /// \param S the Scope of the identifier occurrence.
95
  ///
96
  /// \return true to tell Sema to recover using the LookupResult.
97
183k
  virtual bool LookupUnqualified(LookupResult &R, Scope *S) { return false; }
98
99
  /// Read the set of tentative definitions known to the external Sema
100
  /// source.
101
  ///
102
  /// The external source should append its own tentative definitions to the
103
  /// given vector of tentative definitions. Note that this routine may be
104
  /// invoked multiple times; the external source should take care not to
105
  /// introduce the same declarations repeatedly.
106
  virtual void ReadTentativeDefinitions(
107
10
                                  SmallVectorImpl<VarDecl *> &TentativeDefs) {}
108
109
  /// Read the set of unused file-scope declarations known to the
110
  /// external Sema source.
111
  ///
112
  /// The external source should append its own unused, filed-scope to the
113
  /// given vector of declarations. Note that this routine may be
114
  /// invoked multiple times; the external source should take care not to
115
  /// introduce the same declarations repeatedly.
116
  virtual void ReadUnusedFileScopedDecls(
117
1
                 SmallVectorImpl<const DeclaratorDecl *> &Decls) {}
118
119
  /// Read the set of delegating constructors known to the
120
  /// external Sema source.
121
  ///
122
  /// The external source should append its own delegating constructors to the
123
  /// given vector of declarations. Note that this routine may be
124
  /// invoked multiple times; the external source should take care not to
125
  /// introduce the same declarations repeatedly.
126
  virtual void ReadDelegatingConstructors(
127
9
                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {}
128
129
  /// Read the set of ext_vector type declarations known to the
130
  /// external Sema source.
131
  ///
132
  /// The external source should append its own ext_vector type declarations to
133
  /// the given vector of declarations. Note that this routine may be
134
  /// invoked multiple times; the external source should take care not to
135
  /// introduce the same declarations repeatedly.
136
0
  virtual void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {}
137
138
  /// Read the set of potentially unused typedefs known to the source.
139
  ///
140
  /// The external source should append its own potentially unused local
141
  /// typedefs to the given vector of declarations. Note that this routine may
142
  /// be invoked multiple times; the external source should take care not to
143
  /// introduce the same declarations repeatedly.
144
  virtual void ReadUnusedLocalTypedefNameCandidates(
145
1
      llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {}
146
147
  /// Read the set of referenced selectors known to the
148
  /// external Sema source.
149
  ///
150
  /// The external source should append its own referenced selectors to the
151
  /// given vector of selectors. Note that this routine
152
  /// may be invoked multiple times; the external source should take care not
153
  /// to introduce the same selectors repeatedly.
154
  virtual void ReadReferencedSelectors(
155
10
                 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {}
156
157
  /// Read the set of weak, undeclared identifiers known to the
158
  /// external Sema source.
159
  ///
160
  /// The external source should append its own weak, undeclared identifiers to
161
  /// the given vector. Note that this routine may be invoked multiple times;
162
  /// the external source should take care not to introduce the same identifiers
163
  /// repeatedly.
164
  virtual void ReadWeakUndeclaredIdentifiers(
165
17
                 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WI) {}
166
167
  /// Read the set of used vtables known to the external Sema source.
168
  ///
169
  /// The external source should append its own used vtables to the given
170
  /// vector. Note that this routine may be invoked multiple times; the external
171
  /// source should take care not to introduce the same vtables repeatedly.
172
10
  virtual void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {}
173
174
  /// Read the set of pending instantiations known to the external
175
  /// Sema source.
176
  ///
177
  /// The external source should append its own pending instantiations to the
178
  /// given vector. Note that this routine may be invoked multiple times; the
179
  /// external source should take care not to introduce the same instantiations
180
  /// repeatedly.
181
  virtual void ReadPendingInstantiations(
182
                 SmallVectorImpl<std::pair<ValueDecl *,
183
10
                                           SourceLocation> > &Pending) {}
184
185
  /// Read the set of late parsed template functions for this source.
186
  ///
187
  /// The external source should insert its own late parsed template functions
188
  /// into the map. Note that this routine may be invoked multiple times; the
189
  /// external source should take care not to introduce the same map entries
190
  /// repeatedly.
191
  virtual void ReadLateParsedTemplates(
192
      llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
193
0
          &LPTMap) {}
194
195
  /// \copydoc Sema::CorrectTypo
196
  /// \note LookupKind must correspond to a valid Sema::LookupNameKind
197
  ///
198
  /// ExternalSemaSource::CorrectTypo is always given the first chance to
199
  /// correct a typo (really, to offer suggestions to repair a failed lookup).
200
  /// It will even be called when SpellChecking is turned off or after a
201
  /// fatal error has already been detected.
202
  virtual TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
203
                                     int LookupKind, Scope *S, CXXScopeSpec *SS,
204
                                     CorrectionCandidateCallback &CCC,
205
                                     DeclContext *MemberContext,
206
                                     bool EnteringContext,
207
410
                                     const ObjCObjectPointerType *OPT) {
208
410
    return TypoCorrection();
209
410
  }
210
211
  /// Produces a diagnostic note if the external source contains a
212
  /// complete definition for \p T.
213
  ///
214
  /// \param Loc the location at which a complete type was required but not
215
  /// provided
216
  ///
217
  /// \param T the \c QualType that should have been complete at \p Loc
218
  ///
219
  /// \return true if a diagnostic was produced, false otherwise.
220
  virtual bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc,
221
12
                                                QualType T) {
222
12
    return false;
223
12
  }
224
225
  // isa/cast/dyn_cast support
226
10.5k
  static bool classof(const ExternalASTSource *Source) {
227
10.5k
    return Source->SemaSource;
228
10.5k
  }
229
};
230
231
} // end namespace clang
232
233
#endif