123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433 |
- //===- ExternalASTMerger.cpp - Merging External AST Interface ---*- C++ -*-===//
- //
- // The LLVM Compiler Infrastructure
- //
- // This file is distributed under the University of Illinois Open Source
- // License. See LICENSE.TXT for details.
- //
- //===----------------------------------------------------------------------===//
- //
- // This file implements the ExternalASTMerger, which vends a combination of
- // ASTs from several different ASTContext/FileManager pairs
- //
- //===----------------------------------------------------------------------===//
- #include "clang/AST/ASTContext.h"
- #include "clang/AST/Decl.h"
- #include "clang/AST/DeclCXX.h"
- #include "clang/AST/DeclObjC.h"
- #include "clang/AST/DeclTemplate.h"
- #include "clang/AST/ExternalASTMerger.h"
- using namespace clang;
- namespace {
- template <typename T> struct Source {
- T t;
- Source(T t) : t(t) {}
- operator T() { return t; }
- template <typename U = T> U &get() { return t; }
- template <typename U = T> const U &get() const { return t; }
- template <typename U> operator Source<U>() { return Source<U>(t); }
- };
- typedef std::pair<Source<NamedDecl *>, ASTImporter *> Candidate;
- /// For the given DC, return the DC that is safe to perform lookups on. This is
- /// the DC we actually want to work with most of the time.
- const DeclContext *CanonicalizeDC(const DeclContext *DC) {
- if (isa<LinkageSpecDecl>(DC))
- return DC->getRedeclContext();
- return DC;
- }
- Source<const DeclContext *>
- LookupSameContext(Source<TranslationUnitDecl *> SourceTU, const DeclContext *DC,
- ASTImporter &ReverseImporter) {
- DC = CanonicalizeDC(DC);
- if (DC->isTranslationUnit()) {
- return SourceTU;
- }
- Source<const DeclContext *> SourceParentDC =
- LookupSameContext(SourceTU, DC->getParent(), ReverseImporter);
- if (!SourceParentDC) {
- // If we couldn't find the parent DC in this TranslationUnit, give up.
- return nullptr;
- }
- auto *ND = cast<NamedDecl>(DC);
- DeclarationName Name = ND->getDeclName();
- Source<DeclarationName> SourceName = ReverseImporter.Import(Name);
- DeclContext::lookup_result SearchResult =
- SourceParentDC.get()->lookup(SourceName.get());
- size_t SearchResultSize = SearchResult.size();
- if (SearchResultSize == 0 || SearchResultSize > 1) {
- // There are two cases here. First, we might not find the name.
- // We might also find multiple copies, in which case we have no
- // guarantee that the one we wanted is the one we pick. (E.g.,
- // if we have two specializations of the same template it is
- // very hard to determine which is the one you want.)
- //
- // The Origins map fixes this problem by allowing the origin to be
- // explicitly recorded, so we trigger that recording by returning
- // nothing (rather than a possibly-inaccurate guess) here.
- return nullptr;
- } else {
- NamedDecl *SearchResultDecl = SearchResult[0];
- if (isa<DeclContext>(SearchResultDecl) &&
- SearchResultDecl->getKind() == DC->getDeclKind())
- return cast<DeclContext>(SearchResultDecl)->getPrimaryContext();
- return nullptr; // This type of lookup is unsupported
- }
- }
- /// A custom implementation of ASTImporter, for ExternalASTMerger's purposes.
- ///
- /// There are several modifications:
- ///
- /// - It enables lazy lookup (via the HasExternalLexicalStorage flag and a few
- /// others), which instructs Clang to refer to ExternalASTMerger. Also, it
- /// forces MinimalImport to true, which is necessary to make this work.
- /// - It maintains a reverse importer for use with names. This allows lookup of
- /// arbitrary names in the source context.
- /// - It updates the ExternalASTMerger's origin map as needed whenever a
- /// it sees a DeclContext.
- class LazyASTImporter : public ASTImporter {
- private:
- ExternalASTMerger &Parent;
- ASTImporter Reverse;
- const ExternalASTMerger::OriginMap &FromOrigins;
- llvm::raw_ostream &logs() { return Parent.logs(); }
- public:
- LazyASTImporter(ExternalASTMerger &_Parent, ASTContext &ToContext,
- FileManager &ToFileManager, ASTContext &FromContext,
- FileManager &FromFileManager,
- const ExternalASTMerger::OriginMap &_FromOrigins)
- : ASTImporter(ToContext, ToFileManager, FromContext, FromFileManager,
- /*MinimalImport=*/true),
- Parent(_Parent), Reverse(FromContext, FromFileManager, ToContext,
- ToFileManager, /*MinimalImport=*/true), FromOrigins(_FromOrigins) {}
- /// Whenever a DeclContext is imported, ensure that ExternalASTSource's origin
- /// map is kept up to date. Also set the appropriate flags.
- Decl *Imported(Decl *From, Decl *To) override {
- if (auto *ToDC = dyn_cast<DeclContext>(To)) {
- const bool LoggingEnabled = Parent.LoggingEnabled();
- if (LoggingEnabled)
- logs() << "(ExternalASTMerger*)" << (void*)&Parent
- << " imported (DeclContext*)" << (void*)ToDC
- << ", (ASTContext*)" << (void*)&getToContext()
- << " from (DeclContext*)" << (void*)llvm::cast<DeclContext>(From)
- << ", (ASTContext*)" << (void*)&getFromContext()
- << "\n";
- Source<DeclContext *> FromDC(
- cast<DeclContext>(From)->getPrimaryContext());
- if (FromOrigins.count(FromDC) &&
- Parent.HasImporterForOrigin(*FromOrigins.at(FromDC).AST)) {
- if (LoggingEnabled)
- logs() << "(ExternalASTMerger*)" << (void*)&Parent
- << " forced origin (DeclContext*)"
- << (void*)FromOrigins.at(FromDC).DC
- << ", (ASTContext*)"
- << (void*)FromOrigins.at(FromDC).AST
- << "\n";
- Parent.ForceRecordOrigin(ToDC, FromOrigins.at(FromDC));
- } else {
- if (LoggingEnabled)
- logs() << "(ExternalASTMerger*)" << (void*)&Parent
- << " maybe recording origin (DeclContext*)" << (void*)FromDC
- << ", (ASTContext*)" << (void*)&getFromContext()
- << "\n";
- Parent.MaybeRecordOrigin(ToDC, {FromDC, &getFromContext()});
- }
- }
- if (auto *ToTag = dyn_cast<TagDecl>(To)) {
- ToTag->setHasExternalLexicalStorage();
- ToTag->setMustBuildLookupTable();
- assert(Parent.CanComplete(ToTag));
- } else if (auto *ToNamespace = dyn_cast<NamespaceDecl>(To)) {
- ToNamespace->setHasExternalVisibleStorage();
- assert(Parent.CanComplete(ToNamespace));
- } else if (auto *ToContainer = dyn_cast<ObjCContainerDecl>(To)) {
- ToContainer->setHasExternalLexicalStorage();
- ToContainer->setMustBuildLookupTable();
- assert(Parent.CanComplete(ToContainer));
- }
- return ASTImporter::Imported(From, To);
- }
- ASTImporter &GetReverse() { return Reverse; }
- };
- bool HasDeclOfSameType(llvm::ArrayRef<Candidate> Decls, const Candidate &C) {
- if (isa<FunctionDecl>(C.first.get()))
- return false;
- return llvm::any_of(Decls, [&](const Candidate &D) {
- return C.first.get()->getKind() == D.first.get()->getKind();
- });
- }
- } // end namespace
- ASTImporter &ExternalASTMerger::ImporterForOrigin(ASTContext &OriginContext) {
- for (const std::unique_ptr<ASTImporter> &I : Importers)
- if (&I->getFromContext() == &OriginContext)
- return *I;
- llvm_unreachable("We should have an importer for this origin!");
- }
- namespace {
- LazyASTImporter &LazyImporterForOrigin(ExternalASTMerger &Merger,
- ASTContext &OriginContext) {
- return static_cast<LazyASTImporter &>(
- Merger.ImporterForOrigin(OriginContext));
- }
- }
- bool ExternalASTMerger::HasImporterForOrigin(ASTContext &OriginContext) {
- for (const std::unique_ptr<ASTImporter> &I : Importers)
- if (&I->getFromContext() == &OriginContext)
- return true;
- return false;
- }
- template <typename CallbackType>
- void ExternalASTMerger::ForEachMatchingDC(const DeclContext *DC,
- CallbackType Callback) {
- if (Origins.count(DC)) {
- ExternalASTMerger::DCOrigin Origin = Origins[DC];
- LazyASTImporter &Importer = LazyImporterForOrigin(*this, *Origin.AST);
- Callback(Importer, Importer.GetReverse(), Origin.DC);
- } else {
- bool DidCallback = false;
- for (const std::unique_ptr<ASTImporter> &Importer : Importers) {
- Source<TranslationUnitDecl *> SourceTU =
- Importer->getFromContext().getTranslationUnitDecl();
- ASTImporter &Reverse =
- static_cast<LazyASTImporter *>(Importer.get())->GetReverse();
- if (auto SourceDC = LookupSameContext(SourceTU, DC, Reverse)) {
- DidCallback = true;
- if (Callback(*Importer, Reverse, SourceDC))
- break;
- }
- }
- if (!DidCallback && LoggingEnabled())
- logs() << "(ExternalASTMerger*)" << (void*)this
- << " asserting for (DeclContext*)" << (const void*)DC
- << ", (ASTContext*)" << (void*)&Target.AST
- << "\n";
- assert(DidCallback && "Couldn't find a source context matching our DC");
- }
- }
- void ExternalASTMerger::CompleteType(TagDecl *Tag) {
- assert(Tag->hasExternalLexicalStorage());
- ForEachMatchingDC(Tag, [&](ASTImporter &Forward, ASTImporter &Reverse,
- Source<const DeclContext *> SourceDC) -> bool {
- auto *SourceTag = const_cast<TagDecl *>(cast<TagDecl>(SourceDC.get()));
- if (SourceTag->hasExternalLexicalStorage())
- SourceTag->getASTContext().getExternalSource()->CompleteType(SourceTag);
- if (!SourceTag->getDefinition())
- return false;
- Forward.Imported(SourceTag, Tag);
- Forward.ImportDefinition(SourceTag);
- Tag->setCompleteDefinition(SourceTag->isCompleteDefinition());
- return true;
- });
- }
- void ExternalASTMerger::CompleteType(ObjCInterfaceDecl *Interface) {
- assert(Interface->hasExternalLexicalStorage());
- ForEachMatchingDC(
- Interface, [&](ASTImporter &Forward, ASTImporter &Reverse,
- Source<const DeclContext *> SourceDC) -> bool {
- auto *SourceInterface = const_cast<ObjCInterfaceDecl *>(
- cast<ObjCInterfaceDecl>(SourceDC.get()));
- if (SourceInterface->hasExternalLexicalStorage())
- SourceInterface->getASTContext().getExternalSource()->CompleteType(
- SourceInterface);
- if (!SourceInterface->getDefinition())
- return false;
- Forward.Imported(SourceInterface, Interface);
- Forward.ImportDefinition(SourceInterface);
- return true;
- });
- }
- bool ExternalASTMerger::CanComplete(DeclContext *Interface) {
- assert(Interface->hasExternalLexicalStorage() ||
- Interface->hasExternalVisibleStorage());
- bool FoundMatchingDC = false;
- ForEachMatchingDC(Interface,
- [&](ASTImporter &Forward, ASTImporter &Reverse,
- Source<const DeclContext *> SourceDC) -> bool {
- FoundMatchingDC = true;
- return true;
- });
- return FoundMatchingDC;
- }
- namespace {
- bool IsSameDC(const DeclContext *D1, const DeclContext *D2) {
- if (isa<ObjCContainerDecl>(D1) && isa<ObjCContainerDecl>(D2))
- return true; // There are many cases where Objective-C is ambiguous.
- if (auto *T1 = dyn_cast<TagDecl>(D1))
- if (auto *T2 = dyn_cast<TagDecl>(D2))
- if (T1->getFirstDecl() == T2->getFirstDecl())
- return true;
- return D1 == D2 || D1 == CanonicalizeDC(D2);
- }
- }
- void ExternalASTMerger::MaybeRecordOrigin(const DeclContext *ToDC,
- DCOrigin Origin) {
- LazyASTImporter &Importer = LazyImporterForOrigin(*this, *Origin.AST);
- ASTImporter &Reverse = Importer.GetReverse();
- Source<const DeclContext *> FoundFromDC =
- LookupSameContext(Origin.AST->getTranslationUnitDecl(), ToDC, Reverse);
- const bool DoRecord = !FoundFromDC || !IsSameDC(FoundFromDC.get(), Origin.DC);
- if (DoRecord)
- RecordOriginImpl(ToDC, Origin, Importer);
- if (LoggingEnabled())
- logs() << "(ExternalASTMerger*)" << (void*)this
- << (DoRecord ? " decided " : " decided NOT")
- << " to record origin (DeclContext*)" << (void*)Origin.DC
- << ", (ASTContext*)" << (void*)&Origin.AST
- << "\n";
- }
- void ExternalASTMerger::ForceRecordOrigin(const DeclContext *ToDC,
- DCOrigin Origin) {
- RecordOriginImpl(ToDC, Origin, ImporterForOrigin(*Origin.AST));
- }
- void ExternalASTMerger::RecordOriginImpl(const DeclContext *ToDC, DCOrigin Origin,
- ASTImporter &Importer) {
- Origins[ToDC] = Origin;
- Importer.ASTImporter::Imported(cast<Decl>(Origin.DC), const_cast<Decl*>(cast<Decl>(ToDC)));
- }
- ExternalASTMerger::ExternalASTMerger(const ImporterTarget &Target,
- llvm::ArrayRef<ImporterSource> Sources) : LogStream(&llvm::nulls()), Target(Target) {
- AddSources(Sources);
- }
- void ExternalASTMerger::AddSources(llvm::ArrayRef<ImporterSource> Sources) {
- for (const ImporterSource &S : Sources) {
- assert(&S.AST != &Target.AST);
- Importers.push_back(llvm::make_unique<LazyASTImporter>(
- *this, Target.AST, Target.FM, S.AST, S.FM, S.OM));
- }
- }
- void ExternalASTMerger::RemoveSources(llvm::ArrayRef<ImporterSource> Sources) {
- if (LoggingEnabled())
- for (const ImporterSource &S : Sources)
- logs() << "(ExternalASTMerger*)" << (void*)this
- << " removing source (ASTContext*)" << (void*)&S.AST
- << "\n";
- Importers.erase(
- std::remove_if(Importers.begin(), Importers.end(),
- [&Sources](std::unique_ptr<ASTImporter> &Importer) -> bool {
- for (const ImporterSource &S : Sources) {
- if (&Importer->getFromContext() == &S.AST)
- return true;
- }
- return false;
- }),
- Importers.end());
- for (OriginMap::iterator OI = Origins.begin(), OE = Origins.end(); OI != OE; ) {
- std::pair<const DeclContext *, DCOrigin> Origin = *OI;
- bool Erase = false;
- for (const ImporterSource &S : Sources) {
- if (&S.AST == Origin.second.AST) {
- Erase = true;
- break;
- }
- }
- if (Erase)
- OI = Origins.erase(OI);
- else
- ++OI;
- }
- }
- template <typename DeclTy>
- static bool importSpecializations(DeclTy *D, ASTImporter *Importer) {
- for (auto *Spec : D->specializations())
- if (!Importer->Import(Spec))
- return true;
- return false;
- }
- /// Imports specializations from template declarations that can be specialized.
- static bool importSpecializationsIfNeeded(Decl *D, ASTImporter *Importer) {
- if (!isa<TemplateDecl>(D))
- return false;
- if (auto *FunctionTD = dyn_cast<FunctionTemplateDecl>(D))
- return importSpecializations(FunctionTD, Importer);
- else if (auto *ClassTD = dyn_cast<ClassTemplateDecl>(D))
- return importSpecializations(ClassTD, Importer);
- else if (auto *VarTD = dyn_cast<VarTemplateDecl>(D))
- return importSpecializations(VarTD, Importer);
- return false;
- }
- bool ExternalASTMerger::FindExternalVisibleDeclsByName(const DeclContext *DC,
- DeclarationName Name) {
- llvm::SmallVector<NamedDecl *, 1> Decls;
- llvm::SmallVector<Candidate, 4> Candidates;
- auto FilterFoundDecl = [&Candidates](const Candidate &C) {
- if (!HasDeclOfSameType(Candidates, C))
- Candidates.push_back(C);
- };
- ForEachMatchingDC(DC, [&](ASTImporter &Forward, ASTImporter &Reverse,
- Source<const DeclContext *> SourceDC) -> bool {
- DeclarationName FromName = Reverse.Import(Name);
- DeclContextLookupResult Result = SourceDC.get()->lookup(FromName);
- for (NamedDecl *FromD : Result) {
- FilterFoundDecl(std::make_pair(FromD, &Forward));
- }
- return false;
- });
- if (Candidates.empty())
- return false;
- Decls.reserve(Candidates.size());
- for (const Candidate &C : Candidates) {
- Decl *LookupRes = C.first.get();
- ASTImporter *Importer = C.second;
- NamedDecl *ND = cast_or_null<NamedDecl>(Importer->Import(LookupRes));
- assert(ND);
- // If we don't import specialization, they are not available via lookup
- // because the lookup result is imported TemplateDecl and it does not
- // reference its specializations until they are imported explicitly.
- bool IsSpecImportFailed =
- importSpecializationsIfNeeded(LookupRes, Importer);
- assert(!IsSpecImportFailed);
- (void)IsSpecImportFailed;
- Decls.push_back(ND);
- }
- SetExternalVisibleDeclsForName(DC, Name, Decls);
- return true;
- }
- void ExternalASTMerger::FindExternalLexicalDecls(
- const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
- SmallVectorImpl<Decl *> &Result) {
- ForEachMatchingDC(DC, [&](ASTImporter &Forward, ASTImporter &Reverse,
- Source<const DeclContext *> SourceDC) -> bool {
- for (const Decl *SourceDecl : SourceDC.get()->decls()) {
- if (IsKindWeWant(SourceDecl->getKind())) {
- Decl *ImportedDecl = Forward.Import(const_cast<Decl *>(SourceDecl));
- assert(!ImportedDecl || IsSameDC(ImportedDecl->getDeclContext(), DC));
- (void)ImportedDecl;
- }
- }
- return false;
- });
- }
|