// Part of the Carbon Language project, under the Apache License v2.0 with LLVM // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // TODO: Remove this once https://github.com/llvm/llvm-project/pull/204458 // is merged. #include "third_party/llvm/multiplex_external_sema_source.h" #include "clang/Sema/Lookup.h" namespace Carbon { // NOLINTBEGIN(modernize-loop-convert) // NOLINTBEGIN(modernize-use-trailing-return-type) // NOLINTBEGIN(readability-identifier-naming) // NOLINTBEGIN(readability-redundant-nested-if) char MultiplexExternalSemaSource::ID; /// Constructs an empty multiplexing external sema source. MultiplexExternalSemaSource::MultiplexExternalSemaSource() = default; /// Constructs a new multiplexing external sema source and appends the /// given element to it. /// MultiplexExternalSemaSource::MultiplexExternalSemaSource( llvm::IntrusiveRefCntPtr S1, llvm::IntrusiveRefCntPtr S2) { Sources.push_back(std::move(S1)); Sources.push_back(std::move(S2)); } /// Appends new source to the source list. /// ///\param[in] source - An ExternalSemaSource. /// void MultiplexExternalSemaSource::AddSource( llvm::IntrusiveRefCntPtr Source) { Sources.push_back(std::move(Source)); } //===----------------------------------------------------------------------===// // ExternalASTSource. //===----------------------------------------------------------------------===// clang::Decl* MultiplexExternalSemaSource::GetExternalDecl( clang::GlobalDeclID ID) { for (size_t i = 0; i < Sources.size(); ++i) { if (clang::Decl* Result = Sources[i]->GetExternalDecl(ID)) { return Result; } } return nullptr; } void MultiplexExternalSemaSource::CompleteRedeclChain(const clang::Decl* D) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->CompleteRedeclChain(D); } } clang::Selector MultiplexExternalSemaSource::GetExternalSelector(uint32_t ID) { clang::Selector Sel; for (size_t i = 0; i < Sources.size(); ++i) { Sel = Sources[i]->GetExternalSelector(ID); if (!Sel.isNull()) { return Sel; } } return Sel; } uint32_t MultiplexExternalSemaSource::GetNumExternalSelectors() { uint32_t total = 0; for (size_t i = 0; i < Sources.size(); ++i) { total += Sources[i]->GetNumExternalSelectors(); } return total; } clang::Stmt* MultiplexExternalSemaSource::GetExternalDeclStmt(uint64_t Offset) { for (size_t i = 0; i < Sources.size(); ++i) { if (clang::Stmt* Result = Sources[i]->GetExternalDeclStmt(Offset)) { return Result; } } return nullptr; } clang::CXXBaseSpecifier* MultiplexExternalSemaSource::GetExternalCXXBaseSpecifiers(uint64_t Offset) { for (size_t i = 0; i < Sources.size(); ++i) { if (clang::CXXBaseSpecifier* R = Sources[i]->GetExternalCXXBaseSpecifiers(Offset)) { return R; } } return nullptr; } clang::CXXCtorInitializer** MultiplexExternalSemaSource::GetExternalCXXCtorInitializers(uint64_t Offset) { for (auto& S : Sources) { if (auto* R = S->GetExternalCXXCtorInitializers(Offset)) { return R; } } return nullptr; } clang::ExternalASTSource::ExtKind MultiplexExternalSemaSource::hasExternalDefinitions(const clang::Decl* D) { for (const auto& S : Sources) { if (auto EK = S->hasExternalDefinitions(D)) { if (EK != EK_ReplyHazy) { return EK; } } } return EK_ReplyHazy; } bool MultiplexExternalSemaSource::wasThisDeclarationADefinition( const clang::FunctionDecl* FD) { for (const auto& S : Sources) { if (S->wasThisDeclarationADefinition(FD)) { return true; } } return false; } bool MultiplexExternalSemaSource::FindExternalVisibleDeclsByName( const clang::DeclContext* DC, clang::DeclarationName Name, const clang::DeclContext* OriginalDC) { bool AnyDeclsFound = false; for (size_t i = 0; i < Sources.size(); ++i) { AnyDeclsFound |= Sources[i]->FindExternalVisibleDeclsByName(DC, Name, OriginalDC); } return AnyDeclsFound; } bool MultiplexExternalSemaSource::LoadExternalSpecializations( const clang::Decl* D, bool OnlyPartial) { bool Loaded = false; for (size_t i = 0; i < Sources.size(); ++i) { Loaded |= Sources[i]->LoadExternalSpecializations(D, OnlyPartial); } return Loaded; } bool MultiplexExternalSemaSource::LoadExternalSpecializations( const clang::Decl* D, llvm::ArrayRef TemplateArgs) { bool AnyNewSpecsLoaded = false; for (size_t i = 0; i < Sources.size(); ++i) { AnyNewSpecsLoaded |= Sources[i]->LoadExternalSpecializations(D, TemplateArgs); } return AnyNewSpecsLoaded; } void MultiplexExternalSemaSource::completeVisibleDeclsMap( const clang::DeclContext* DC) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->completeVisibleDeclsMap(DC); } } void MultiplexExternalSemaSource::FindExternalLexicalDecls( const clang::DeclContext* DC, llvm::function_ref IsKindWeWant, llvm::SmallVectorImpl& Result) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->FindExternalLexicalDecls(DC, IsKindWeWant, Result); } } void MultiplexExternalSemaSource::FindFileRegionDecls( clang::FileID File, unsigned Offset, unsigned Length, llvm::SmallVectorImpl& Decls) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->FindFileRegionDecls(File, Offset, Length, Decls); } } void MultiplexExternalSemaSource::CompleteType(clang::TagDecl* Tag) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->CompleteType(Tag); } } void MultiplexExternalSemaSource::CompleteType( clang::ObjCInterfaceDecl* Class) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->CompleteType(Class); } } void MultiplexExternalSemaSource::ReadComments() { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadComments(); } } void MultiplexExternalSemaSource::StartedDeserializing() { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->StartedDeserializing(); } } void MultiplexExternalSemaSource::FinishedDeserializing() { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->FinishedDeserializing(); } } void MultiplexExternalSemaSource::StartTranslationUnit( clang::ASTConsumer* Consumer) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->StartTranslationUnit(Consumer); } } void MultiplexExternalSemaSource::PrintStats() { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->PrintStats(); } } clang::Module* MultiplexExternalSemaSource::getModule(unsigned ID) { for (size_t i = 0; i < Sources.size(); ++i) { if (auto* M = Sources[i]->getModule(ID)) { return M; } } return nullptr; } bool MultiplexExternalSemaSource::layoutRecordType( const clang::RecordDecl* Record, uint64_t& Size, uint64_t& Alignment, llvm::DenseMap& FieldOffsets, llvm::DenseMap& BaseOffsets, llvm::DenseMap& VirtualBaseOffsets) { for (size_t i = 0; i < Sources.size(); ++i) { if (Sources[i]->layoutRecordType(Record, Size, Alignment, FieldOffsets, BaseOffsets, VirtualBaseOffsets)) { return true; } } return false; } void MultiplexExternalSemaSource::getMemoryBufferSizes( MemoryBufferSizes& sizes) const { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->getMemoryBufferSizes(sizes); } } //===----------------------------------------------------------------------===// // ExternalSemaSource. //===----------------------------------------------------------------------===// void MultiplexExternalSemaSource::InitializeSema(clang::Sema& S) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->InitializeSema(S); } } void MultiplexExternalSemaSource::ForgetSema() { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ForgetSema(); } } void MultiplexExternalSemaSource::ReadMethodPool(clang::Selector Sel) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadMethodPool(Sel); } } void MultiplexExternalSemaSource::updateOutOfDateSelector(clang::Selector Sel) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->updateOutOfDateSelector(Sel); } } void MultiplexExternalSemaSource::ReadKnownNamespaces( llvm::SmallVectorImpl& Namespaces) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadKnownNamespaces(Namespaces); } } void MultiplexExternalSemaSource::ReadUndefinedButUsed( llvm::MapVector& Undefined) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadUndefinedButUsed(Undefined); } } void MultiplexExternalSemaSource::ReadMismatchingDeleteExpressions( llvm::MapVector< clang::FieldDecl*, llvm::SmallVector, 4>>& Exprs) { for (auto& Source : Sources) { Source->ReadMismatchingDeleteExpressions(Exprs); } } bool MultiplexExternalSemaSource::LookupUnqualified(clang::LookupResult& R, clang::Scope* S) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->LookupUnqualified(R, S); } return !R.empty(); } void MultiplexExternalSemaSource::ReadTentativeDefinitions( llvm::SmallVectorImpl& TentativeDefs) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadTentativeDefinitions(TentativeDefs); } } void MultiplexExternalSemaSource::ReadUnusedFileScopedDecls( llvm::SmallVectorImpl& Decls) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadUnusedFileScopedDecls(Decls); } } void MultiplexExternalSemaSource::ReadDelegatingConstructors( llvm::SmallVectorImpl& Decls) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadDelegatingConstructors(Decls); } } void MultiplexExternalSemaSource::ReadExtVectorDecls( llvm::SmallVectorImpl& Decls) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadExtVectorDecls(Decls); } } void MultiplexExternalSemaSource::ReadDeclsToCheckForDeferredDiags( llvm::SmallSetVector& Decls) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadDeclsToCheckForDeferredDiags(Decls); } } void MultiplexExternalSemaSource::ReadUnusedLocalTypedefNameCandidates( llvm::SmallSetVector& Decls) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadUnusedLocalTypedefNameCandidates(Decls); } } void MultiplexExternalSemaSource::ReadReferencedSelectors( llvm::SmallVectorImpl>& Sels) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadReferencedSelectors(Sels); } } void MultiplexExternalSemaSource::ReadWeakUndeclaredIdentifiers( llvm::SmallVectorImpl>& WI) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadWeakUndeclaredIdentifiers(WI); } } void MultiplexExternalSemaSource::ReadExtnameUndeclaredIdentifiers( llvm::SmallVectorImpl< std::pair>& EI) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadExtnameUndeclaredIdentifiers(EI); } } void MultiplexExternalSemaSource::ReadUsedVTables( llvm::SmallVectorImpl& VTables) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadUsedVTables(VTables); } } void MultiplexExternalSemaSource::ReadPendingInstantiations( llvm::SmallVectorImpl>& Pending) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadPendingInstantiations(Pending); } } void MultiplexExternalSemaSource::ReadLateParsedTemplates( llvm::MapVector>& LPTMap) { for (size_t i = 0; i < Sources.size(); ++i) { Sources[i]->ReadLateParsedTemplates(LPTMap); } } clang::TypoCorrection MultiplexExternalSemaSource::CorrectTypo( const clang::DeclarationNameInfo& Typo, int LookupKind, clang::Scope* S, clang::CXXScopeSpec* SS, clang::CorrectionCandidateCallback& CCC, clang::DeclContext* MemberContext, bool EnteringContext, const clang::ObjCObjectPointerType* OPT) { for (size_t I = 0, E = Sources.size(); I < E; ++I) { if (clang::TypoCorrection C = Sources[I]->CorrectTypo(Typo, LookupKind, S, SS, CCC, MemberContext, EnteringContext, OPT)) { return C; } } return clang::TypoCorrection(); } bool MultiplexExternalSemaSource::MaybeDiagnoseMissingCompleteType( clang::SourceLocation Loc, clang::QualType T) { for (size_t I = 0, E = Sources.size(); I < E; ++I) { if (Sources[I]->MaybeDiagnoseMissingCompleteType(Loc, T)) { return true; } } return false; } void MultiplexExternalSemaSource::AssignedLambdaNumbering( clang::CXXRecordDecl* Lambda) { for (auto& Source : Sources) { Source->AssignedLambdaNumbering(Lambda); } } // NOLINTEND(readability-redundant-nested-if) // NOLINTEND(readability-identifier-naming) // NOLINTEND(modernize-use-trailing-return-type) // NOLINTEND(modernize-loop-convert) } // namespace Carbon