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
Indexes created Wed Jun 10 00:26:05 UTC 2026