vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
541 lines
22 KiB
C++
541 lines
22 KiB
C++
//===- ExternalASTMerger.cpp - Merging External AST 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 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();
|
|
auto SourceNameOrErr = ReverseImporter.Import(Name);
|
|
if (!SourceNameOrErr) {
|
|
llvm::consumeError(SourceNameOrErr.takeError());
|
|
return nullptr;
|
|
}
|
|
Source<DeclarationName> SourceName = *SourceNameOrErr;
|
|
DeclContext::lookup_result SearchResult =
|
|
SourceParentDC.get()->lookup(SourceName.get());
|
|
|
|
// 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.
|
|
if (SearchResult.isSingleResult()) {
|
|
NamedDecl *SearchResultDecl = SearchResult.front();
|
|
if (isa<DeclContext>(SearchResultDecl) &&
|
|
SearchResultDecl->getKind() == DC->getDeclKind())
|
|
return cast<DeclContext>(SearchResultDecl)->getPrimaryContext();
|
|
return nullptr; // This type of lookup is unsupported
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
/// 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;
|
|
/// @see ExternalASTMerger::ImporterSource::Temporary
|
|
bool TemporarySource;
|
|
/// Map of imported declarations back to the declarations they originated
|
|
/// from.
|
|
llvm::DenseMap<Decl *, Decl *> ToOrigin;
|
|
/// @see ExternalASTMerger::ImporterSource::Merger
|
|
ExternalASTMerger *SourceMerger;
|
|
llvm::raw_ostream &logs() { return Parent.logs(); }
|
|
public:
|
|
LazyASTImporter(ExternalASTMerger &_Parent, ASTContext &ToContext,
|
|
FileManager &ToFileManager,
|
|
const ExternalASTMerger::ImporterSource &S,
|
|
std::shared_ptr<ASTImporterSharedState> SharedState)
|
|
: ASTImporter(ToContext, ToFileManager, S.getASTContext(),
|
|
S.getFileManager(),
|
|
/*MinimalImport=*/true, SharedState),
|
|
Parent(_Parent),
|
|
Reverse(S.getASTContext(), S.getFileManager(), ToContext, ToFileManager,
|
|
/*MinimalImport=*/true),
|
|
FromOrigins(S.getOriginMap()), TemporarySource(S.isTemporary()),
|
|
SourceMerger(S.getMerger()) {}
|
|
|
|
llvm::Expected<Decl *> ImportImpl(Decl *FromD) override {
|
|
if (!TemporarySource || !SourceMerger)
|
|
return ASTImporter::ImportImpl(FromD);
|
|
|
|
// If we get here, then this source is importing from a temporary ASTContext
|
|
// that also has another ExternalASTMerger attached. It could be
|
|
// possible that the current ExternalASTMerger and the temporary ASTContext
|
|
// share a common ImporterSource, which means that the temporary
|
|
// AST could contain declarations that were imported from a source
|
|
// that this ExternalASTMerger can access directly. Instead of importing
|
|
// such declarations from the temporary ASTContext, they should instead
|
|
// be directly imported by this ExternalASTMerger from the original
|
|
// source. This way the ExternalASTMerger can safely do a minimal import
|
|
// without creating incomplete declarations originated from a temporary
|
|
// ASTContext. If we would try to complete such declarations later on, we
|
|
// would fail to do so as their temporary AST could be deleted (which means
|
|
// that the missing parts of the minimally imported declaration in that
|
|
// ASTContext were also deleted).
|
|
//
|
|
// The following code tracks back any declaration that needs to be
|
|
// imported from the temporary ASTContext to a persistent ASTContext.
|
|
// Then the ExternalASTMerger tries to import from the persistent
|
|
// ASTContext directly by using the associated ASTImporter. If that
|
|
// succeeds, this ASTImporter just maps the declarations imported by
|
|
// the other (persistent) ASTImporter to this (temporary) ASTImporter.
|
|
// The steps can be visualized like this:
|
|
//
|
|
// Target AST <--- 3. Indirect import --- Persistent AST
|
|
// ^ of persistent decl ^
|
|
// | |
|
|
// 1. Current import 2. Tracking back to persistent decl
|
|
// 4. Map persistent decl |
|
|
// & pretend we imported. |
|
|
// | |
|
|
// Temporary AST -------------------------------'
|
|
|
|
// First, ask the ExternalASTMerger of the source where the temporary
|
|
// declaration originated from.
|
|
Decl *Persistent = SourceMerger->FindOriginalDecl(FromD);
|
|
// FromD isn't from a persistent AST, so just do a normal import.
|
|
if (!Persistent)
|
|
return ASTImporter::ImportImpl(FromD);
|
|
// Now ask the current ExternalASTMerger to try import the persistent
|
|
// declaration into the target.
|
|
ASTContext &PersistentCtx = Persistent->getASTContext();
|
|
ASTImporter &OtherImporter = Parent.ImporterForOrigin(PersistentCtx);
|
|
// Check that we never end up in the current Importer again.
|
|
assert((&PersistentCtx != &getFromContext()) && (&OtherImporter != this) &&
|
|
"Delegated to same Importer?");
|
|
auto DeclOrErr = OtherImporter.Import(Persistent);
|
|
// Errors when importing the persistent decl are treated as if we
|
|
// had errors with importing the temporary decl.
|
|
if (!DeclOrErr)
|
|
return DeclOrErr.takeError();
|
|
Decl *D = *DeclOrErr;
|
|
// Tell the current ASTImporter that this has already been imported
|
|
// to prevent any further queries for the temporary decl.
|
|
MapImported(FromD, D);
|
|
return D;
|
|
}
|
|
|
|
/// Implements the ASTImporter interface for tracking back a declaration
|
|
/// to its original declaration it came from.
|
|
Decl *GetOriginalDecl(Decl *To) override {
|
|
return ToOrigin.lookup(To);
|
|
}
|
|
|
|
/// Whenever a DeclContext is imported, ensure that ExternalASTSource's origin
|
|
/// map is kept up to date. Also set the appropriate flags.
|
|
void Imported(Decl *From, Decl *To) override {
|
|
ToOrigin[To] = From;
|
|
|
|
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 (auto It = FromOrigins.find(FromDC);
|
|
It != FromOrigins.end() &&
|
|
Parent.HasImporterForOrigin(*It->second.AST)) {
|
|
if (LoggingEnabled)
|
|
logs() << "(ExternalASTMerger*)" << (void *)&Parent
|
|
<< " forced origin (DeclContext*)" << (void *)It->second.DC
|
|
<< ", (ASTContext*)" << (void *)It->second.AST << "\n";
|
|
Parent.ForceRecordOrigin(ToDC, It->second);
|
|
} 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->getPrimaryContext()->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->getPrimaryContext()->setMustBuildLookupTable();
|
|
assert(Parent.CanComplete(ToContainer));
|
|
}
|
|
}
|
|
ASTImporter &GetReverse() { return Reverse; }
|
|
};
|
|
|
|
bool HasDeclOfSameType(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 (auto It = Origins.find(DC); It != Origins.end()) {
|
|
ExternalASTMerger::DCOrigin Origin = It->second;
|
|
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.MapImported(SourceTag, Tag);
|
|
if (llvm::Error Err = Forward.ImportDefinition(SourceTag))
|
|
llvm::consumeError(std::move(Err));
|
|
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.MapImported(SourceInterface, Interface);
|
|
if (llvm::Error Err = Forward.ImportDefinition(SourceInterface))
|
|
llvm::consumeError(std::move(Err));
|
|
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::MapImported(cast<Decl>(Origin.DC), const_cast<Decl*>(cast<Decl>(ToDC)));
|
|
}
|
|
|
|
ExternalASTMerger::ExternalASTMerger(const ImporterTarget &Target,
|
|
ArrayRef<ImporterSource> Sources)
|
|
: LogStream(&llvm::nulls()), Target(Target) {
|
|
SharedState = std::make_shared<ASTImporterSharedState>(
|
|
*Target.AST.getTranslationUnitDecl());
|
|
AddSources(Sources);
|
|
}
|
|
|
|
Decl *ExternalASTMerger::FindOriginalDecl(Decl *D) {
|
|
assert(&D->getASTContext() == &Target.AST);
|
|
for (const auto &I : Importers)
|
|
if (auto Result = I->GetOriginalDecl(D))
|
|
return Result;
|
|
return nullptr;
|
|
}
|
|
|
|
void ExternalASTMerger::AddSources(ArrayRef<ImporterSource> Sources) {
|
|
for (const ImporterSource &S : Sources) {
|
|
assert(&S.getASTContext() != &Target.AST);
|
|
// Check that the associated merger actually imports into the source AST.
|
|
assert(!S.getMerger() || &S.getMerger()->Target.AST == &S.getASTContext());
|
|
Importers.push_back(std::make_unique<LazyASTImporter>(
|
|
*this, Target.AST, Target.FM, S, SharedState));
|
|
}
|
|
}
|
|
|
|
void ExternalASTMerger::RemoveSources(ArrayRef<ImporterSource> Sources) {
|
|
if (LoggingEnabled())
|
|
for (const ImporterSource &S : Sources)
|
|
logs() << "(ExternalASTMerger*)" << (void *)this
|
|
<< " removing source (ASTContext*)" << (void *)&S.getASTContext()
|
|
<< "\n";
|
|
llvm::erase_if(Importers,
|
|
[&Sources](std::unique_ptr<ASTImporter> &Importer) -> bool {
|
|
for (const ImporterSource &S : Sources) {
|
|
if (&Importer->getFromContext() == &S.getASTContext())
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
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.getASTContext() == 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()) {
|
|
auto ImportedSpecOrError = Importer->Import(Spec);
|
|
if (!ImportedSpecOrError) {
|
|
llvm::consumeError(ImportedSpecOrError.takeError());
|
|
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,
|
|
const DeclContext *OriginalDC) {
|
|
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 {
|
|
auto FromNameOrErr = Reverse.Import(Name);
|
|
if (!FromNameOrErr) {
|
|
llvm::consumeError(FromNameOrErr.takeError());
|
|
return false;
|
|
}
|
|
DeclContextLookupResult Result =
|
|
SourceDC.get()->lookup(*FromNameOrErr);
|
|
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;
|
|
auto NDOrErr = Importer->Import(LookupRes);
|
|
NamedDecl *ND = cast<NamedDecl>(llvm::cantFail(std::move(NDOrErr)));
|
|
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())) {
|
|
auto ImportedDeclOrErr = Forward.Import(SourceDecl);
|
|
if (ImportedDeclOrErr)
|
|
assert(!(*ImportedDeclOrErr) ||
|
|
IsSameDC((*ImportedDeclOrErr)->getDeclContext(), DC));
|
|
else
|
|
llvm::consumeError(ImportedDeclOrErr.takeError());
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|