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