1 //===--- MultiplexExternalSemaSource.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 ExternalSemaSource interface, dispatching to all clients 10 // 11 //===----------------------------------------------------------------------===// 12 #ifndef LLVM_CLANG_SEMA_MULTIPLEXEXTERNALSEMASOURCE_H 13 #define LLVM_CLANG_SEMA_MULTIPLEXEXTERNALSEMASOURCE_H 14 15 #include "clang/Sema/ExternalSemaSource.h" 16 #include "clang/Sema/Weak.h" 17 #include "llvm/ADT/SmallVector.h" 18 #include <utility> 19 20 namespace clang { 21 22 class CXXConstructorDecl; 23 class CXXRecordDecl; 24 class DeclaratorDecl; 25 struct ExternalVTableUse; 26 class LookupResult; 27 class NamespaceDecl; 28 class Scope; 29 class Sema; 30 class TypedefNameDecl; 31 class ValueDecl; 32 class VarDecl; 33 34 35 /// An abstract interface that should be implemented by 36 /// external AST sources that also provide information for semantic 37 /// analysis. 38 class MultiplexExternalSemaSource : public ExternalSemaSource { 39 /// LLVM-style RTTI. 40 static char ID; 41 42 private: 43 SmallVector<ExternalSemaSource *, 2> Sources; 44 45 public: 46 /// 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() override; 55 56 /// 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 /// Resolve a declaration ID into a declaration, potentially 67 /// building a new declaration. 68 Decl *GetExternalDecl(GlobalDeclID ID) override; 69 70 /// Complete the redeclaration chain if it's been extended since the 71 /// previous generation of the AST source. 72 void CompleteRedeclChain(const Decl *D) override; 73 74 /// Resolve a selector ID into a selector. 75 Selector GetExternalSelector(uint32_t ID) override; 76 77 /// Returns the number of selectors known to the external AST 78 /// source. 79 uint32_t GetNumExternalSelectors() override; 80 81 /// Resolve the offset of a statement in the decl stream into 82 /// a statement. 83 Stmt *GetExternalDeclStmt(uint64_t Offset) override; 84 85 /// Resolve the offset of a set of C++ base specifiers in the decl 86 /// stream into an array of specifiers. 87 CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset) override; 88 89 /// Resolve a handle to a list of ctor initializers into the list of 90 /// initializers themselves. 91 CXXCtorInitializer **GetExternalCXXCtorInitializers(uint64_t Offset) override; 92 93 ExtKind hasExternalDefinitions(const Decl *D) override; 94 95 /// Find all declarations with the given name in the 96 /// given context. 97 bool FindExternalVisibleDeclsByName(const DeclContext *DC, 98 DeclarationName Name) override; 99 100 /// Ensures that the table of all visible declarations inside this 101 /// context is up to date. 102 void completeVisibleDeclsMap(const DeclContext *DC) override; 103 104 /// Finds all declarations lexically contained within the given 105 /// DeclContext, after applying an optional filter predicate. 106 /// 107 /// \param IsKindWeWant a predicate function that returns true if the passed 108 /// declaration kind is one we are looking for. 109 void 110 FindExternalLexicalDecls(const DeclContext *DC, 111 llvm::function_ref<bool(Decl::Kind)> IsKindWeWant, 112 SmallVectorImpl<Decl *> &Result) override; 113 114 /// Get the decls that are contained in a file in the Offset/Length 115 /// range. \p Length can be 0 to indicate a point at \p Offset instead of 116 /// a range. 117 void FindFileRegionDecls(FileID File, unsigned Offset,unsigned Length, 118 SmallVectorImpl<Decl *> &Decls) override; 119 120 /// Gives the external AST source an opportunity to complete 121 /// an incomplete type. 122 void CompleteType(TagDecl *Tag) override; 123 124 /// Gives the external AST source an opportunity to complete an 125 /// incomplete Objective-C class. 126 /// 127 /// This routine will only be invoked if the "externally completed" bit is 128 /// set on the ObjCInterfaceDecl via the function 129 /// \c ObjCInterfaceDecl::setExternallyCompleted(). 130 void CompleteType(ObjCInterfaceDecl *Class) override; 131 132 /// Loads comment ranges. 133 void ReadComments() override; 134 135 /// Notify ExternalASTSource that we started deserialization of 136 /// a decl or type so until FinishedDeserializing is called there may be 137 /// decls that are initializing. Must be paired with FinishedDeserializing. 138 void StartedDeserializing() override; 139 140 /// Notify ExternalASTSource that we finished the deserialization of 141 /// a decl or type. Must be paired with StartedDeserializing. 142 void FinishedDeserializing() override; 143 144 /// Function that will be invoked when we begin parsing a new 145 /// translation unit involving this external AST source. 146 void StartTranslationUnit(ASTConsumer *Consumer) override; 147 148 /// Print any statistics that have been gathered regarding 149 /// the external AST source. 150 void PrintStats() override; 151 152 /// Retrieve the module that corresponds to the given module ID. 153 Module *getModule(unsigned ID) override; 154 155 /// Perform layout on the given record. 156 /// 157 /// This routine allows the external AST source to provide an specific 158 /// layout for a record, overriding the layout that would normally be 159 /// constructed. It is intended for clients who receive specific layout 160 /// details rather than source code (such as LLDB). The client is expected 161 /// to fill in the field offsets, base offsets, virtual base offsets, and 162 /// complete object size. 163 /// 164 /// \param Record The record whose layout is being requested. 165 /// 166 /// \param Size The final size of the record, in bits. 167 /// 168 /// \param Alignment The final alignment of the record, in bits. 169 /// 170 /// \param FieldOffsets The offset of each of the fields within the record, 171 /// expressed in bits. All of the fields must be provided with offsets. 172 /// 173 /// \param BaseOffsets The offset of each of the direct, non-virtual base 174 /// classes. If any bases are not given offsets, the bases will be laid 175 /// out according to the ABI. 176 /// 177 /// \param VirtualBaseOffsets The offset of each of the virtual base classes 178 /// (either direct or not). If any bases are not given offsets, the bases will 179 /// be laid out according to the ABI. 180 /// 181 /// \returns true if the record layout was provided, false otherwise. 182 bool 183 layoutRecordType(const RecordDecl *Record, 184 uint64_t &Size, uint64_t &Alignment, 185 llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets, 186 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets, 187 llvm::DenseMap<const CXXRecordDecl *, 188 CharUnits> &VirtualBaseOffsets) override; 189 190 /// Return the amount of memory used by memory buffers, breaking down 191 /// by heap-backed versus mmap'ed memory. 192 void getMemoryBufferSizes(MemoryBufferSizes &sizes) const override; 193 194 //===--------------------------------------------------------------------===// 195 // ExternalSemaSource. 196 //===--------------------------------------------------------------------===// 197 198 /// Initialize the semantic source with the Sema instance 199 /// being used to perform semantic analysis on the abstract syntax 200 /// tree. 201 void InitializeSema(Sema &S) override; 202 203 /// Inform the semantic consumer that Sema is no longer available. 204 void ForgetSema() override; 205 206 /// Load the contents of the global method pool for a given 207 /// selector. 208 void ReadMethodPool(Selector Sel) override; 209 210 /// Load the contents of the global method pool for a given 211 /// selector if necessary. 212 void updateOutOfDateSelector(Selector Sel) override; 213 214 /// Load the set of namespaces that are known to the external source, 215 /// which will be used during typo correction. 216 void 217 ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl*> &Namespaces) override; 218 219 /// Load the set of used but not defined functions or variables with 220 /// internal linkage, or used but not defined inline functions. 221 void ReadUndefinedButUsed( 222 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) override; 223 224 void ReadMismatchingDeleteExpressions(llvm::MapVector< 225 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> & 226 Exprs) override; 227 228 /// Do last resort, unqualified lookup on a LookupResult that 229 /// Sema cannot find. 230 /// 231 /// \param R a LookupResult that is being recovered. 232 /// 233 /// \param S the Scope of the identifier occurrence. 234 /// 235 /// \return true to tell Sema to recover using the LookupResult. 236 bool LookupUnqualified(LookupResult &R, Scope *S) override; 237 238 /// Read the set of tentative definitions known to the external Sema 239 /// source. 240 /// 241 /// The external source should append its own tentative definitions to the 242 /// given vector of tentative definitions. Note that this routine may be 243 /// invoked multiple times; the external source should take care not to 244 /// introduce the same declarations repeatedly. 245 void ReadTentativeDefinitions(SmallVectorImpl<VarDecl*> &Defs) override; 246 247 /// Read the set of unused file-scope declarations known to the 248 /// external Sema source. 249 /// 250 /// The external source should append its own unused, filed-scope to the 251 /// given vector of declarations. Note that this routine may be 252 /// invoked multiple times; the external source should take care not to 253 /// introduce the same declarations repeatedly. 254 void ReadUnusedFileScopedDecls( 255 SmallVectorImpl<const DeclaratorDecl*> &Decls) override; 256 257 /// Read the set of delegating constructors known to the 258 /// external Sema source. 259 /// 260 /// The external source should append its own delegating constructors to the 261 /// given vector of declarations. Note that this routine may be 262 /// invoked multiple times; the external source should take care not to 263 /// introduce the same declarations repeatedly. 264 void ReadDelegatingConstructors( 265 SmallVectorImpl<CXXConstructorDecl*> &Decls) override; 266 267 /// Read the set of ext_vector type declarations known to the 268 /// external Sema source. 269 /// 270 /// The external source should append its own ext_vector type declarations to 271 /// the given vector of declarations. Note that this routine may be 272 /// invoked multiple times; the external source should take care not to 273 /// introduce the same declarations repeatedly. 274 void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl*> &Decls) override; 275 276 /// Read the set of potentially unused typedefs known to the source. 277 /// 278 /// The external source should append its own potentially unused local 279 /// typedefs to the given vector of declarations. Note that this routine may 280 /// be invoked multiple times; the external source should take care not to 281 /// introduce the same declarations repeatedly. 282 void ReadUnusedLocalTypedefNameCandidates( 283 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) override; 284 285 /// Read the set of referenced selectors known to the 286 /// external Sema source. 287 /// 288 /// The external source should append its own referenced selectors to the 289 /// given vector of selectors. Note that this routine 290 /// may be invoked multiple times; the external source should take care not 291 /// to introduce the same selectors repeatedly. 292 void ReadReferencedSelectors(SmallVectorImpl<std::pair<Selector, 293 SourceLocation> > &Sels) override; 294 295 /// Read the set of weak, undeclared identifiers known to the 296 /// external Sema source. 297 /// 298 /// The external source should append its own weak, undeclared identifiers to 299 /// the given vector. Note that this routine may be invoked multiple times; 300 /// the external source should take care not to introduce the same identifiers 301 /// repeatedly. 302 void ReadWeakUndeclaredIdentifiers( 303 SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI) override; 304 305 /// Read the set of used vtables known to the external Sema source. 306 /// 307 /// The external source should append its own used vtables to the given 308 /// vector. Note that this routine may be invoked multiple times; the external 309 /// source should take care not to introduce the same vtables repeatedly. 310 void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) override; 311 312 /// Read the set of pending instantiations known to the external 313 /// Sema source. 314 /// 315 /// The external source should append its own pending instantiations to the 316 /// given vector. Note that this routine may be invoked multiple times; the 317 /// external source should take care not to introduce the same instantiations 318 /// repeatedly. 319 void ReadPendingInstantiations( 320 SmallVectorImpl<std::pair<ValueDecl*, SourceLocation> >& Pending) override; 321 322 /// Read the set of late parsed template functions for this source. 323 /// 324 /// The external source should insert its own late parsed template functions 325 /// into the map. Note that this routine may be invoked multiple times; the 326 /// external source should take care not to introduce the same map entries 327 /// repeatedly. 328 void ReadLateParsedTemplates( 329 llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>> 330 &LPTMap) override; 331 332 /// Read the set of decls to be checked for deferred diags. 333 /// 334 /// The external source should append its own potentially emitted function 335 /// and variable decls which may cause deferred diags. Note that this routine 336 /// may be invoked multiple times; the external source should take care not to 337 /// introduce the same declarations repeatedly. 338 void ReadDeclsToCheckForDeferredDiags( 339 llvm::SmallSetVector<Decl *, 4> &Decls) override; 340 341 /// \copydoc ExternalSemaSource::CorrectTypo 342 /// \note Returns the first nonempty correction. 343 TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, 344 int LookupKind, Scope *S, CXXScopeSpec *SS, 345 CorrectionCandidateCallback &CCC, 346 DeclContext *MemberContext, 347 bool EnteringContext, 348 const ObjCObjectPointerType *OPT) override; 349 350 /// Produces a diagnostic note if one of the attached sources 351 /// contains a complete definition for \p T. Queries the sources in list 352 /// order until the first one claims that a diagnostic was produced. 353 /// 354 /// \param Loc the location at which a complete type was required but not 355 /// provided 356 /// 357 /// \param T the \c QualType that should have been complete at \p Loc 358 /// 359 /// \return true if a diagnostic was produced, false otherwise. 360 bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc, 361 QualType T) override; 362 363 // Inform all attached sources that a mangling number was assigned. 364 void AssignedLambdaNumbering(const CXXRecordDecl *Lambda) override; 365 366 /// LLVM-style RTTI. 367 /// \{ isA(const void * ClassID)368 bool isA(const void *ClassID) const override { 369 return ClassID == &ID || ExternalSemaSource::isA(ClassID); 370 } classof(const ExternalASTSource * S)371 static bool classof(const ExternalASTSource *S) { return S->isA(&ID); } 372 /// \} 373 }; 374 375 } // end namespace clang 376 377 #endif 378