1 //===--- ExternalSemaSource.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 the ExternalSemaSource interface.
11 //
12 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H
14 #define LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H
15 
16 #include "clang/AST/ExternalASTSource.h"
17 #include "clang/AST/Type.h"
18 #include "clang/Sema/TypoCorrection.h"
19 #include "clang/Sema/Weak.h"
20 #include "llvm/ADT/MapVector.h"
21 #include <utility>
22 
23 namespace llvm {
24 template <class T, unsigned n> class SmallSetVector;
25 }
26 
27 namespace clang {
28 
29 class CXXConstructorDecl;
30 class CXXDeleteExpr;
31 class CXXRecordDecl;
32 class DeclaratorDecl;
33 class LookupResult;
34 struct ObjCMethodList;
35 class Scope;
36 class Sema;
37 class TypedefNameDecl;
38 class ValueDecl;
39 class VarDecl;
40 struct LateParsedTemplate;
41 
42 /// \brief A simple structure that captures a vtable use for the purposes of
43 /// the \c ExternalSemaSource.
44 struct ExternalVTableUse {
45   CXXRecordDecl *Record;
46   SourceLocation Location;
47   bool DefinitionRequired;
48 };
49 
50 /// \brief An abstract interface that should be implemented by
51 /// external AST sources that also provide information for semantic
52 /// analysis.
53 class ExternalSemaSource : public ExternalASTSource {
54 public:
ExternalSemaSource()55   ExternalSemaSource() {
56     ExternalASTSource::SemaSource = true;
57   }
58 
59   ~ExternalSemaSource() override;
60 
61   /// \brief Initialize the semantic source with the Sema instance
62   /// being used to perform semantic analysis on the abstract syntax
63   /// tree.
InitializeSema(Sema & S)64   virtual void InitializeSema(Sema &S) {}
65 
66   /// \brief Inform the semantic consumer that Sema is no longer available.
ForgetSema()67   virtual void ForgetSema() {}
68 
69   /// \brief 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   /// \brief 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   /// \brief 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   /// \brief 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.
LookupUnqualified(LookupResult & R,Scope * S)98   virtual bool LookupUnqualified(LookupResult &R, Scope *S) { return false; }
99 
100   /// \brief 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.
ReadTentativeDefinitions(SmallVectorImpl<VarDecl * > & TentativeDefs)107   virtual void ReadTentativeDefinitions(
108                                   SmallVectorImpl<VarDecl *> &TentativeDefs) {}
109 
110   /// \brief 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.
ReadUnusedFileScopedDecls(SmallVectorImpl<const DeclaratorDecl * > & Decls)117   virtual void ReadUnusedFileScopedDecls(
118                  SmallVectorImpl<const DeclaratorDecl *> &Decls) {}
119 
120   /// \brief 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.
ReadDelegatingConstructors(SmallVectorImpl<CXXConstructorDecl * > & Decls)127   virtual void ReadDelegatingConstructors(
128                  SmallVectorImpl<CXXConstructorDecl *> &Decls) {}
129 
130   /// \brief 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.
ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl * > & Decls)137   virtual void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {}
138 
139   /// \brief 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.
ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector<const TypedefNameDecl *,4> & Decls)145   virtual void ReadUnusedLocalTypedefNameCandidates(
146       llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {}
147 
148   /// \brief 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.
ReadReferencedSelectors(SmallVectorImpl<std::pair<Selector,SourceLocation>> & Sels)155   virtual void ReadReferencedSelectors(
156                  SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {}
157 
158   /// \brief 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.
ReadWeakUndeclaredIdentifiers(SmallVectorImpl<std::pair<IdentifierInfo *,WeakInfo>> & WI)165   virtual void ReadWeakUndeclaredIdentifiers(
166                  SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WI) {}
167 
168   /// \brief 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.
ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> & VTables)173   virtual void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {}
174 
175   /// \brief 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.
ReadPendingInstantiations(SmallVectorImpl<std::pair<ValueDecl *,SourceLocation>> & Pending)182   virtual void ReadPendingInstantiations(
183                  SmallVectorImpl<std::pair<ValueDecl *,
184                                            SourceLocation> > &Pending) {}
185 
186   /// \brief 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.
ReadLateParsedTemplates(llvm::MapVector<const FunctionDecl *,LateParsedTemplate * > & LPTMap)192   virtual void ReadLateParsedTemplates(
193       llvm::MapVector<const FunctionDecl *, LateParsedTemplate *> &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.
CorrectTypo(const DeclarationNameInfo & Typo,int LookupKind,Scope * S,CXXScopeSpec * SS,CorrectionCandidateCallback & CCC,DeclContext * MemberContext,bool EnteringContext,const ObjCObjectPointerType * OPT)202   virtual TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
203                                      int LookupKind, Scope *S, CXXScopeSpec *SS,
204                                      CorrectionCandidateCallback &CCC,
205                                      DeclContext *MemberContext,
206                                      bool EnteringContext,
207                                      const ObjCObjectPointerType *OPT) {
208     return TypoCorrection();
209   }
210 
211   /// \brief 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.
MaybeDiagnoseMissingCompleteType(SourceLocation Loc,QualType T)220   virtual bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc,
221                                                 QualType T) {
222     return false;
223   }
224 
225   // isa/cast/dyn_cast support
classof(const ExternalASTSource * Source)226   static bool classof(const ExternalASTSource *Source) {
227     return Source->SemaSource;
228   }
229 };
230 
231 } // end namespace clang
232 
233 #endif
234