MultiplexExternalSemaSource.h revision 3646c68676c3c46a026b23d52188ef6e0d856178
1//===--- MultiplexExternalSemaSource.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 ExternalSemaSource interface, dispatching to all clients 11// 12//===----------------------------------------------------------------------===// 13#ifndef LLVM_CLANG_SEMA_MULTIPLEX_EXTERNAL_SEMA_SOURCE_H 14#define LLVM_CLANG_SEMA_MULTIPLEX_EXTERNAL_SEMA_SOURCE_H 15 16#include "clang/Sema/ExternalSemaSource.h" 17#include "clang/Sema/Weak.h" 18#include "llvm/ADT/SmallVector.h" 19#include <utility> 20 21namespace clang { 22 23 class CXXConstructorDecl; 24 class CXXRecordDecl; 25 class DeclaratorDecl; 26 struct ExternalVTableUse; 27 class LookupResult; 28 class NamespaceDecl; 29 class Scope; 30 class Sema; 31 class TypedefNameDecl; 32 class ValueDecl; 33 class VarDecl; 34 35 36/// \brief An abstract interface that should be implemented by 37/// external AST sources that also provide information for semantic 38/// analysis. 39class MultiplexExternalSemaSource : public ExternalSemaSource { 40 41private: 42 SmallVector<ExternalSemaSource *, 2> Sources; // doesn't own them. 43 44public: 45 46 ///\brief Constructs a new multiplexing external sema source and appends the 47 /// given element to it. 48 /// 49 ///\param[in] s1 - A non-null (old) ExternalSemaSource. 50 ///\param[in] s2 - A non-null (new) ExternalSemaSource. 51 /// 52 MultiplexExternalSemaSource(ExternalSemaSource& s1, ExternalSemaSource& s2); 53 54 ~MultiplexExternalSemaSource(); 55 56 ///\brief Appends new source to the source list. 57 /// 58 ///\param[in] source - An ExternalSemaSource. 59 /// 60 void addSource(ExternalSemaSource &source); 61 62 //===--------------------------------------------------------------------===// 63 // ExternalASTSource. 64 //===--------------------------------------------------------------------===// 65 66 /// \brief Resolve a declaration ID into a declaration, potentially 67 /// building a new declaration. 68 virtual Decl *GetExternalDecl(uint32_t ID); 69 70 /// \brief Resolve a selector ID into a selector. 71 virtual Selector GetExternalSelector(uint32_t ID); 72 73 /// \brief Returns the number of selectors known to the external AST 74 /// source. 75 virtual uint32_t GetNumExternalSelectors(); 76 77 /// \brief Resolve the offset of a statement in the decl stream into 78 /// a statement. 79 virtual Stmt *GetExternalDeclStmt(uint64_t Offset); 80 81 /// \brief Resolve the offset of a set of C++ base specifiers in the decl 82 /// stream into an array of specifiers. 83 virtual CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset); 84 85 /// \brief Find all declarations with the given name in the 86 /// given context. 87 virtual bool 88 FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name); 89 90 /// \brief Ensures that the table of all visible declarations inside this 91 /// context is up to date. 92 virtual void completeVisibleDeclsMap(const DeclContext *DC); 93 94 /// \brief Finds all declarations lexically contained within the given 95 /// DeclContext, after applying an optional filter predicate. 96 /// 97 /// \param isKindWeWant a predicate function that returns true if the passed 98 /// declaration kind is one we are looking for. If NULL, all declarations 99 /// are returned. 100 /// 101 /// \return an indication of whether the load succeeded or failed. 102 virtual ExternalLoadResult FindExternalLexicalDecls(const DeclContext *DC, 103 bool (*isKindWeWant)(Decl::Kind), 104 SmallVectorImpl<Decl*> &Result); 105 106 /// \brief Finds all declarations lexically contained within the given 107 /// DeclContext. 108 /// 109 /// \return true if an error occurred 110 ExternalLoadResult FindExternalLexicalDecls(const DeclContext *DC, 111 SmallVectorImpl<Decl*> &Result) { 112 return FindExternalLexicalDecls(DC, 0, Result); 113 } 114 115 template <typename DeclTy> 116 ExternalLoadResult FindExternalLexicalDeclsBy(const DeclContext *DC, 117 SmallVectorImpl<Decl*> &Result) { 118 return FindExternalLexicalDecls(DC, DeclTy::classofKind, Result); 119 } 120 121 /// \brief Get the decls that are contained in a file in the Offset/Length 122 /// range. \p Length can be 0 to indicate a point at \p Offset instead of 123 /// a range. 124 virtual void FindFileRegionDecls(FileID File, unsigned Offset,unsigned Length, 125 SmallVectorImpl<Decl *> &Decls); 126 127 /// \brief Gives the external AST source an opportunity to complete 128 /// an incomplete type. 129 virtual void CompleteType(TagDecl *Tag); 130 131 /// \brief Gives the external AST source an opportunity to complete an 132 /// incomplete Objective-C class. 133 /// 134 /// This routine will only be invoked if the "externally completed" bit is 135 /// set on the ObjCInterfaceDecl via the function 136 /// \c ObjCInterfaceDecl::setExternallyCompleted(). 137 virtual void CompleteType(ObjCInterfaceDecl *Class); 138 139 /// \brief Loads comment ranges. 140 virtual void ReadComments(); 141 142 /// \brief Notify ExternalASTSource that we started deserialization of 143 /// a decl or type so until FinishedDeserializing is called there may be 144 /// decls that are initializing. Must be paired with FinishedDeserializing. 145 virtual void StartedDeserializing(); 146 147 /// \brief Notify ExternalASTSource that we finished the deserialization of 148 /// a decl or type. Must be paired with StartedDeserializing. 149 virtual void FinishedDeserializing(); 150 151 /// \brief Function that will be invoked when we begin parsing a new 152 /// translation unit involving this external AST source. 153 virtual void StartTranslationUnit(ASTConsumer *Consumer); 154 155 /// \brief Print any statistics that have been gathered regarding 156 /// the external AST source. 157 virtual void PrintStats(); 158 159 160 /// \brief Perform layout on the given record. 161 /// 162 /// This routine allows the external AST source to provide an specific 163 /// layout for a record, overriding the layout that would normally be 164 /// constructed. It is intended for clients who receive specific layout 165 /// details rather than source code (such as LLDB). The client is expected 166 /// to fill in the field offsets, base offsets, virtual base offsets, and 167 /// complete object size. 168 /// 169 /// \param Record The record whose layout is being requested. 170 /// 171 /// \param Size The final size of the record, in bits. 172 /// 173 /// \param Alignment The final alignment of the record, in bits. 174 /// 175 /// \param FieldOffsets The offset of each of the fields within the record, 176 /// expressed in bits. All of the fields must be provided with offsets. 177 /// 178 /// \param BaseOffsets The offset of each of the direct, non-virtual base 179 /// classes. If any bases are not given offsets, the bases will be laid 180 /// out according to the ABI. 181 /// 182 /// \param VirtualBaseOffsets The offset of each of the virtual base classes 183 /// (either direct or not). If any bases are not given offsets, the bases will 184 /// be laid out according to the ABI. 185 /// 186 /// \returns true if the record layout was provided, false otherwise. 187 virtual bool 188 layoutRecordType(const RecordDecl *Record, 189 uint64_t &Size, uint64_t &Alignment, 190 llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets, 191 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets, 192 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets); 193 194 /// Return the amount of memory used by memory buffers, breaking down 195 /// by heap-backed versus mmap'ed memory. 196 virtual void getMemoryBufferSizes(MemoryBufferSizes &sizes) const; 197 198 //===--------------------------------------------------------------------===// 199 // ExternalSemaSource. 200 //===--------------------------------------------------------------------===// 201 202 /// \brief Initialize the semantic source with the Sema instance 203 /// being used to perform semantic analysis on the abstract syntax 204 /// tree. 205 virtual void InitializeSema(Sema &S); 206 207 /// \brief Inform the semantic consumer that Sema is no longer available. 208 virtual void ForgetSema(); 209 210 /// \brief Load the contents of the global method pool for a given 211 /// selector. 212 virtual void ReadMethodPool(Selector Sel); 213 214 /// \brief Load the set of namespaces that are known to the external source, 215 /// which will be used during typo correction. 216 virtual void ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl*> &Namespaces); 217 218 /// \brief Load the set of used but not defined functions or variables with 219 /// internal linkage, or used but not defined inline functions. 220 virtual void ReadUndefinedButUsed( 221 llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined); 222 223 /// \brief Do last resort, unqualified lookup on a LookupResult that 224 /// Sema cannot find. 225 /// 226 /// \param R a LookupResult that is being recovered. 227 /// 228 /// \param S the Scope of the identifier occurrence. 229 /// 230 /// \return true to tell Sema to recover using the LookupResult. 231 virtual bool LookupUnqualified(LookupResult &R, Scope *S); 232 233 /// \brief Read the set of tentative definitions known to the external Sema 234 /// source. 235 /// 236 /// The external source should append its own tentative definitions to the 237 /// given vector of tentative definitions. Note that this routine may be 238 /// invoked multiple times; the external source should take care not to 239 /// introduce the same declarations repeatedly. 240 virtual void ReadTentativeDefinitions(SmallVectorImpl<VarDecl*> &Defs); 241 242 /// \brief Read the set of unused file-scope declarations known to the 243 /// external Sema source. 244 /// 245 /// The external source should append its own unused, filed-scope to the 246 /// given vector of declarations. Note that this routine may be 247 /// invoked multiple times; the external source should take care not to 248 /// introduce the same declarations repeatedly. 249 virtual void ReadUnusedFileScopedDecls( 250 SmallVectorImpl<const DeclaratorDecl*> &Decls); 251 252 /// \brief Read the set of delegating constructors known to the 253 /// external Sema source. 254 /// 255 /// The external source should append its own delegating constructors to the 256 /// given vector of declarations. Note that this routine may be 257 /// invoked multiple times; the external source should take care not to 258 /// introduce the same declarations repeatedly. 259 virtual void ReadDelegatingConstructors( 260 SmallVectorImpl<CXXConstructorDecl*> &Decls); 261 262 /// \brief Read the set of ext_vector type declarations known to the 263 /// external Sema source. 264 /// 265 /// The external source should append its own ext_vector type declarations to 266 /// the given vector of declarations. Note that this routine may be 267 /// invoked multiple times; the external source should take care not to 268 /// introduce the same declarations repeatedly. 269 virtual void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl*> &Decls); 270 271 /// \brief Read the set of dynamic classes known to the external Sema source. 272 /// 273 /// The external source should append its own dynamic classes to 274 /// the given vector of declarations. Note that this routine may be 275 /// invoked multiple times; the external source should take care not to 276 /// introduce the same declarations repeatedly. 277 virtual void ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl*> &Decls); 278 279 /// \brief Read the set of locally-scoped extern "C" declarations known to the 280 /// external Sema source. 281 /// 282 /// The external source should append its own locally-scoped external 283 /// declarations to the given vector of declarations. Note that this routine 284 /// may be invoked multiple times; the external source should take care not 285 /// to introduce the same declarations repeatedly. 286 virtual void ReadLocallyScopedExternCDecls(SmallVectorImpl<NamedDecl*>&Decls); 287 288 /// \brief Read the set of referenced selectors known to the 289 /// external Sema source. 290 /// 291 /// The external source should append its own referenced selectors to the 292 /// given vector of selectors. Note that this routine 293 /// may be invoked multiple times; the external source should take care not 294 /// to introduce the same selectors repeatedly. 295 virtual void ReadReferencedSelectors(SmallVectorImpl<std::pair<Selector, 296 SourceLocation> > &Sels); 297 298 /// \brief Read the set of weak, undeclared identifiers known to the 299 /// external Sema source. 300 /// 301 /// The external source should append its own weak, undeclared identifiers to 302 /// the given vector. Note that this routine may be invoked multiple times; 303 /// the external source should take care not to introduce the same identifiers 304 /// repeatedly. 305 virtual void ReadWeakUndeclaredIdentifiers( 306 SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI); 307 308 /// \brief Read the set of used vtables known to the external Sema source. 309 /// 310 /// The external source should append its own used vtables to the given 311 /// vector. Note that this routine may be invoked multiple times; the external 312 /// source should take care not to introduce the same vtables repeatedly. 313 virtual void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables); 314 315 /// \brief Read the set of pending instantiations known to the external 316 /// Sema source. 317 /// 318 /// The external source should append its own pending instantiations to the 319 /// given vector. Note that this routine may be invoked multiple times; the 320 /// external source should take care not to introduce the same instantiations 321 /// repeatedly. 322 virtual void ReadPendingInstantiations( 323 SmallVectorImpl<std::pair<ValueDecl*, SourceLocation> >& Pending); 324 325 // isa/cast/dyn_cast support 326 static bool classof(const MultiplexExternalSemaSource*) { return true; } 327 //static bool classof(const ExternalSemaSource*) { return true; } 328}; 329 330} // end namespace clang 331 332#endif // LLVM_CLANG_SEMA_MULTIPLEX_EXTERNAL_SEMA_SOURCE_H 333