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   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   virtual void InitializeSema(Sema &S) {}
65 
66   /// Inform the semantic consumer that Sema is no longer available.
67   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   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                                   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                  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                  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   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       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                  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                  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   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                                            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           &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
203   ReadDeclsToCheckForDeferredDiags(llvm::SmallSetVector<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                                      const ObjCObjectPointerType *OPT) {
218     return TypoCorrection();
219   }
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                                                 QualType T) {
232     return false;
233   }
234 
235   /// LLVM-style RTTI.
236   /// \{
237   bool isA(const void *ClassID) const override {
238     return ClassID == &ID || ExternalASTSource::isA(ClassID);
239   }
240   static bool classof(const ExternalASTSource *S) { return S->isA(&ID); }
241   /// \}
242 };
243 
244 } // end namespace clang
245 
246 #endif
247