6024e5c395
clang 20.0.0 (based on r547379) from build 12806354. Bug: http://b/379133546 Test: N/A Change-Id: I2eb8938af55d809de674be63cb30cf27e801862b Upstream-Commit: ad834e67b1105d15ef907f6255d4c96e8e733f57
378 lines
16 KiB
C++
378 lines
16 KiB
C++
//===--- MultiplexExternalSemaSource.h - External Sema Interface-*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines ExternalSemaSource interface, dispatching to all clients
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#ifndef LLVM_CLANG_SEMA_MULTIPLEXEXTERNALSEMASOURCE_H
|
|
#define LLVM_CLANG_SEMA_MULTIPLEXEXTERNALSEMASOURCE_H
|
|
|
|
#include "clang/Sema/ExternalSemaSource.h"
|
|
#include "clang/Sema/Weak.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include <utility>
|
|
|
|
namespace clang {
|
|
|
|
class CXXConstructorDecl;
|
|
class CXXRecordDecl;
|
|
class DeclaratorDecl;
|
|
struct ExternalVTableUse;
|
|
class LookupResult;
|
|
class NamespaceDecl;
|
|
class Scope;
|
|
class Sema;
|
|
class TypedefNameDecl;
|
|
class ValueDecl;
|
|
class VarDecl;
|
|
|
|
|
|
/// An abstract interface that should be implemented by
|
|
/// external AST sources that also provide information for semantic
|
|
/// analysis.
|
|
class MultiplexExternalSemaSource : public ExternalSemaSource {
|
|
/// LLVM-style RTTI.
|
|
static char ID;
|
|
|
|
private:
|
|
SmallVector<ExternalSemaSource *, 2> Sources;
|
|
|
|
public:
|
|
/// Constructs a new multiplexing external sema source and appends the
|
|
/// given element to it.
|
|
///
|
|
///\param[in] S1 - A non-null (old) ExternalSemaSource.
|
|
///\param[in] S2 - A non-null (new) ExternalSemaSource.
|
|
///
|
|
MultiplexExternalSemaSource(ExternalSemaSource *S1, ExternalSemaSource *S2);
|
|
|
|
~MultiplexExternalSemaSource() override;
|
|
|
|
/// Appends new source to the source list.
|
|
///
|
|
///\param[in] Source - An ExternalSemaSource.
|
|
///
|
|
void AddSource(ExternalSemaSource *Source);
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// ExternalASTSource.
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Resolve a declaration ID into a declaration, potentially
|
|
/// building a new declaration.
|
|
Decl *GetExternalDecl(GlobalDeclID ID) override;
|
|
|
|
/// Complete the redeclaration chain if it's been extended since the
|
|
/// previous generation of the AST source.
|
|
void CompleteRedeclChain(const Decl *D) override;
|
|
|
|
/// Resolve a selector ID into a selector.
|
|
Selector GetExternalSelector(uint32_t ID) override;
|
|
|
|
/// Returns the number of selectors known to the external AST
|
|
/// source.
|
|
uint32_t GetNumExternalSelectors() override;
|
|
|
|
/// Resolve the offset of a statement in the decl stream into
|
|
/// a statement.
|
|
Stmt *GetExternalDeclStmt(uint64_t Offset) override;
|
|
|
|
/// Resolve the offset of a set of C++ base specifiers in the decl
|
|
/// stream into an array of specifiers.
|
|
CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset) override;
|
|
|
|
/// Resolve a handle to a list of ctor initializers into the list of
|
|
/// initializers themselves.
|
|
CXXCtorInitializer **GetExternalCXXCtorInitializers(uint64_t Offset) override;
|
|
|
|
ExtKind hasExternalDefinitions(const Decl *D) override;
|
|
|
|
/// Find all declarations with the given name in the
|
|
/// given context.
|
|
bool FindExternalVisibleDeclsByName(const DeclContext *DC,
|
|
DeclarationName Name) override;
|
|
|
|
/// Ensures that the table of all visible declarations inside this
|
|
/// context is up to date.
|
|
void completeVisibleDeclsMap(const DeclContext *DC) override;
|
|
|
|
/// Finds all declarations lexically contained within the given
|
|
/// DeclContext, after applying an optional filter predicate.
|
|
///
|
|
/// \param IsKindWeWant a predicate function that returns true if the passed
|
|
/// declaration kind is one we are looking for.
|
|
void
|
|
FindExternalLexicalDecls(const DeclContext *DC,
|
|
llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
|
|
SmallVectorImpl<Decl *> &Result) override;
|
|
|
|
/// Get the decls that are contained in a file in the Offset/Length
|
|
/// range. \p Length can be 0 to indicate a point at \p Offset instead of
|
|
/// a range.
|
|
void FindFileRegionDecls(FileID File, unsigned Offset,unsigned Length,
|
|
SmallVectorImpl<Decl *> &Decls) override;
|
|
|
|
/// Gives the external AST source an opportunity to complete
|
|
/// an incomplete type.
|
|
void CompleteType(TagDecl *Tag) override;
|
|
|
|
/// Gives the external AST source an opportunity to complete an
|
|
/// incomplete Objective-C class.
|
|
///
|
|
/// This routine will only be invoked if the "externally completed" bit is
|
|
/// set on the ObjCInterfaceDecl via the function
|
|
/// \c ObjCInterfaceDecl::setExternallyCompleted().
|
|
void CompleteType(ObjCInterfaceDecl *Class) override;
|
|
|
|
/// Loads comment ranges.
|
|
void ReadComments() override;
|
|
|
|
/// Notify ExternalASTSource that we started deserialization of
|
|
/// a decl or type so until FinishedDeserializing is called there may be
|
|
/// decls that are initializing. Must be paired with FinishedDeserializing.
|
|
void StartedDeserializing() override;
|
|
|
|
/// Notify ExternalASTSource that we finished the deserialization of
|
|
/// a decl or type. Must be paired with StartedDeserializing.
|
|
void FinishedDeserializing() override;
|
|
|
|
/// Function that will be invoked when we begin parsing a new
|
|
/// translation unit involving this external AST source.
|
|
void StartTranslationUnit(ASTConsumer *Consumer) override;
|
|
|
|
/// Print any statistics that have been gathered regarding
|
|
/// the external AST source.
|
|
void PrintStats() override;
|
|
|
|
/// Retrieve the module that corresponds to the given module ID.
|
|
Module *getModule(unsigned ID) override;
|
|
|
|
/// Perform layout on the given record.
|
|
///
|
|
/// This routine allows the external AST source to provide an specific
|
|
/// layout for a record, overriding the layout that would normally be
|
|
/// constructed. It is intended for clients who receive specific layout
|
|
/// details rather than source code (such as LLDB). The client is expected
|
|
/// to fill in the field offsets, base offsets, virtual base offsets, and
|
|
/// complete object size.
|
|
///
|
|
/// \param Record The record whose layout is being requested.
|
|
///
|
|
/// \param Size The final size of the record, in bits.
|
|
///
|
|
/// \param Alignment The final alignment of the record, in bits.
|
|
///
|
|
/// \param FieldOffsets The offset of each of the fields within the record,
|
|
/// expressed in bits. All of the fields must be provided with offsets.
|
|
///
|
|
/// \param BaseOffsets The offset of each of the direct, non-virtual base
|
|
/// classes. If any bases are not given offsets, the bases will be laid
|
|
/// out according to the ABI.
|
|
///
|
|
/// \param VirtualBaseOffsets The offset of each of the virtual base classes
|
|
/// (either direct or not). If any bases are not given offsets, the bases will
|
|
/// be laid out according to the ABI.
|
|
///
|
|
/// \returns true if the record layout was provided, false otherwise.
|
|
bool
|
|
layoutRecordType(const RecordDecl *Record,
|
|
uint64_t &Size, uint64_t &Alignment,
|
|
llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
|
|
llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
|
|
llvm::DenseMap<const CXXRecordDecl *,
|
|
CharUnits> &VirtualBaseOffsets) override;
|
|
|
|
/// Return the amount of memory used by memory buffers, breaking down
|
|
/// by heap-backed versus mmap'ed memory.
|
|
void getMemoryBufferSizes(MemoryBufferSizes &sizes) const override;
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// ExternalSemaSource.
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Initialize the semantic source with the Sema instance
|
|
/// being used to perform semantic analysis on the abstract syntax
|
|
/// tree.
|
|
void InitializeSema(Sema &S) override;
|
|
|
|
/// Inform the semantic consumer that Sema is no longer available.
|
|
void ForgetSema() override;
|
|
|
|
/// Load the contents of the global method pool for a given
|
|
/// selector.
|
|
void ReadMethodPool(Selector Sel) override;
|
|
|
|
/// Load the contents of the global method pool for a given
|
|
/// selector if necessary.
|
|
void updateOutOfDateSelector(Selector Sel) override;
|
|
|
|
/// Load the set of namespaces that are known to the external source,
|
|
/// which will be used during typo correction.
|
|
void
|
|
ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl*> &Namespaces) override;
|
|
|
|
/// Load the set of used but not defined functions or variables with
|
|
/// internal linkage, or used but not defined inline functions.
|
|
void ReadUndefinedButUsed(
|
|
llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) override;
|
|
|
|
void ReadMismatchingDeleteExpressions(llvm::MapVector<
|
|
FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
|
|
Exprs) override;
|
|
|
|
/// Do last resort, unqualified lookup on a LookupResult that
|
|
/// Sema cannot find.
|
|
///
|
|
/// \param R a LookupResult that is being recovered.
|
|
///
|
|
/// \param S the Scope of the identifier occurrence.
|
|
///
|
|
/// \return true to tell Sema to recover using the LookupResult.
|
|
bool LookupUnqualified(LookupResult &R, Scope *S) override;
|
|
|
|
/// Read the set of tentative definitions known to the external Sema
|
|
/// source.
|
|
///
|
|
/// The external source should append its own tentative definitions to the
|
|
/// given vector of tentative definitions. Note that this routine may be
|
|
/// invoked multiple times; the external source should take care not to
|
|
/// introduce the same declarations repeatedly.
|
|
void ReadTentativeDefinitions(SmallVectorImpl<VarDecl*> &Defs) override;
|
|
|
|
/// Read the set of unused file-scope declarations known to the
|
|
/// external Sema source.
|
|
///
|
|
/// The external source should append its own unused, filed-scope to the
|
|
/// given vector of declarations. Note that this routine may be
|
|
/// invoked multiple times; the external source should take care not to
|
|
/// introduce the same declarations repeatedly.
|
|
void ReadUnusedFileScopedDecls(
|
|
SmallVectorImpl<const DeclaratorDecl*> &Decls) override;
|
|
|
|
/// Read the set of delegating constructors known to the
|
|
/// external Sema source.
|
|
///
|
|
/// The external source should append its own delegating constructors to the
|
|
/// given vector of declarations. Note that this routine may be
|
|
/// invoked multiple times; the external source should take care not to
|
|
/// introduce the same declarations repeatedly.
|
|
void ReadDelegatingConstructors(
|
|
SmallVectorImpl<CXXConstructorDecl*> &Decls) override;
|
|
|
|
/// Read the set of ext_vector type declarations known to the
|
|
/// external Sema source.
|
|
///
|
|
/// The external source should append its own ext_vector type declarations to
|
|
/// the given vector of declarations. Note that this routine may be
|
|
/// invoked multiple times; the external source should take care not to
|
|
/// introduce the same declarations repeatedly.
|
|
void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl*> &Decls) override;
|
|
|
|
/// Read the set of potentially unused typedefs known to the source.
|
|
///
|
|
/// The external source should append its own potentially unused local
|
|
/// typedefs to the given vector of declarations. Note that this routine may
|
|
/// be invoked multiple times; the external source should take care not to
|
|
/// introduce the same declarations repeatedly.
|
|
void ReadUnusedLocalTypedefNameCandidates(
|
|
llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) override;
|
|
|
|
/// Read the set of referenced selectors known to the
|
|
/// external Sema source.
|
|
///
|
|
/// The external source should append its own referenced selectors to the
|
|
/// given vector of selectors. Note that this routine
|
|
/// may be invoked multiple times; the external source should take care not
|
|
/// to introduce the same selectors repeatedly.
|
|
void ReadReferencedSelectors(SmallVectorImpl<std::pair<Selector,
|
|
SourceLocation> > &Sels) override;
|
|
|
|
/// Read the set of weak, undeclared identifiers known to the
|
|
/// external Sema source.
|
|
///
|
|
/// The external source should append its own weak, undeclared identifiers to
|
|
/// the given vector. Note that this routine may be invoked multiple times;
|
|
/// the external source should take care not to introduce the same identifiers
|
|
/// repeatedly.
|
|
void ReadWeakUndeclaredIdentifiers(
|
|
SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI) override;
|
|
|
|
/// Read the set of used vtables known to the external Sema source.
|
|
///
|
|
/// The external source should append its own used vtables to the given
|
|
/// vector. Note that this routine may be invoked multiple times; the external
|
|
/// source should take care not to introduce the same vtables repeatedly.
|
|
void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) override;
|
|
|
|
/// Read the set of pending instantiations known to the external
|
|
/// Sema source.
|
|
///
|
|
/// The external source should append its own pending instantiations to the
|
|
/// given vector. Note that this routine may be invoked multiple times; the
|
|
/// external source should take care not to introduce the same instantiations
|
|
/// repeatedly.
|
|
void ReadPendingInstantiations(
|
|
SmallVectorImpl<std::pair<ValueDecl*, SourceLocation> >& Pending) override;
|
|
|
|
/// Read the set of late parsed template functions for this source.
|
|
///
|
|
/// The external source should insert its own late parsed template functions
|
|
/// into the map. Note that this routine may be invoked multiple times; the
|
|
/// external source should take care not to introduce the same map entries
|
|
/// repeatedly.
|
|
void ReadLateParsedTemplates(
|
|
llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
|
|
&LPTMap) override;
|
|
|
|
/// Read the set of decls to be checked for deferred diags.
|
|
///
|
|
/// The external source should append its own potentially emitted function
|
|
/// and variable decls which may cause deferred diags. Note that this routine
|
|
/// may be invoked multiple times; the external source should take care not to
|
|
/// introduce the same declarations repeatedly.
|
|
void ReadDeclsToCheckForDeferredDiags(
|
|
llvm::SmallSetVector<Decl *, 4> &Decls) override;
|
|
|
|
/// \copydoc ExternalSemaSource::CorrectTypo
|
|
/// \note Returns the first nonempty correction.
|
|
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
|
|
int LookupKind, Scope *S, CXXScopeSpec *SS,
|
|
CorrectionCandidateCallback &CCC,
|
|
DeclContext *MemberContext,
|
|
bool EnteringContext,
|
|
const ObjCObjectPointerType *OPT) override;
|
|
|
|
/// Produces a diagnostic note if one of the attached sources
|
|
/// contains a complete definition for \p T. Queries the sources in list
|
|
/// order until the first one claims that a diagnostic was produced.
|
|
///
|
|
/// \param Loc the location at which a complete type was required but not
|
|
/// provided
|
|
///
|
|
/// \param T the \c QualType that should have been complete at \p Loc
|
|
///
|
|
/// \return true if a diagnostic was produced, false otherwise.
|
|
bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc,
|
|
QualType T) override;
|
|
|
|
// Inform all attached sources that a mangling number was assigned.
|
|
void AssignedLambdaNumbering(const CXXRecordDecl *Lambda) override;
|
|
|
|
/// LLVM-style RTTI.
|
|
/// \{
|
|
bool isA(const void *ClassID) const override {
|
|
return ClassID == &ID || ExternalSemaSource::isA(ClassID);
|
|
}
|
|
static bool classof(const ExternalASTSource *S) { return S->isA(&ID); }
|
|
/// \}
|
|
};
|
|
|
|
} // end namespace clang
|
|
|
|
#endif
|