mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
0047d81f9a
We noticed some Swift clients rely on the serialized search paths in the module to find dependencies and droping these paths altogether can lead to build failures like rdar://85840921. This change teaches the serialization to obfuscate the search paths and the deserialization to recover them. This allows clients to keep accessing these paths without exposing them when shipping the module to other users.
1307 lines
44 KiB
C++
1307 lines
44 KiB
C++
//===--- ModuleFile.cpp - Loading a serialized module ---------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "ModuleFile.h"
|
|
#include "ModuleFileCoreTableInfo.h"
|
|
#include "BCReadingExtras.h"
|
|
#include "DeserializationErrors.h"
|
|
#include "ModuleFormat.h"
|
|
#include "swift/Serialization/SerializationOptions.h"
|
|
#include "swift/Subsystems.h"
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/ASTMangler.h"
|
|
#include "swift/AST/GenericSignature.h"
|
|
#include "swift/AST/ModuleLoader.h"
|
|
#include "swift/AST/NameLookup.h"
|
|
#include "swift/AST/PrettyStackTrace.h"
|
|
#include "swift/AST/USRGeneration.h"
|
|
#include "swift/Basic/Range.h"
|
|
#include "swift/ClangImporter/ClangImporter.h"
|
|
#include "swift/Serialization/SerializedModuleLoader.h"
|
|
#include "llvm/ADT/StringExtras.h"
|
|
#include "llvm/Support/Chrono.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/OnDiskHashTable.h"
|
|
|
|
using namespace swift;
|
|
using namespace swift::serialization;
|
|
using namespace llvm::support;
|
|
using llvm::Expected;
|
|
|
|
static_assert(IsTriviallyDestructible<SerializedASTFile>::value,
|
|
"SerializedASTFiles are BumpPtrAllocated; d'tors are not called");
|
|
|
|
static bool areCompatibleArchitectures(const llvm::Triple &moduleTarget,
|
|
const llvm::Triple &ctxTarget) {
|
|
if (moduleTarget.getArch() == ctxTarget.getArch())
|
|
return true;
|
|
|
|
// Special case: ARM and Thumb are compatible.
|
|
const llvm::Triple::ArchType moduleArch = moduleTarget.getArch();
|
|
const llvm::Triple::ArchType ctxArch = ctxTarget.getArch();
|
|
if ((moduleArch == llvm::Triple::arm && ctxArch == llvm::Triple::thumb) ||
|
|
(moduleArch == llvm::Triple::thumb && ctxArch == llvm::Triple::arm))
|
|
return true;
|
|
if ((moduleArch == llvm::Triple::armeb && ctxArch == llvm::Triple::thumbeb) ||
|
|
(moduleArch == llvm::Triple::thumbeb && ctxArch == llvm::Triple::armeb))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool areCompatibleOSs(const llvm::Triple &moduleTarget,
|
|
const llvm::Triple &ctxTarget) {
|
|
if ((!moduleTarget.hasEnvironment() && ctxTarget.isSimulatorEnvironment()) ||
|
|
(!ctxTarget.hasEnvironment() && moduleTarget.isSimulatorEnvironment()))
|
|
return false;
|
|
|
|
if (moduleTarget.getOS() == ctxTarget.getOS())
|
|
return true;
|
|
|
|
// Special case: macOS and Darwin are compatible.
|
|
const llvm::Triple::OSType moduleOS = moduleTarget.getOS();
|
|
const llvm::Triple::OSType ctxOS = ctxTarget.getOS();
|
|
if ((moduleOS == llvm::Triple::Darwin && ctxOS == llvm::Triple::MacOSX) ||
|
|
(moduleOS == llvm::Triple::MacOSX && ctxOS == llvm::Triple::Darwin))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool isTargetTooNew(const llvm::Triple &moduleTarget,
|
|
const llvm::Triple &ctxTarget) {
|
|
unsigned major, minor, micro;
|
|
|
|
if (moduleTarget.isMacOSX()) {
|
|
moduleTarget.getMacOSXVersion(major, minor, micro);
|
|
return ctxTarget.isMacOSXVersionLT(major, minor, micro);
|
|
}
|
|
|
|
moduleTarget.getOSVersion(major, minor, micro);
|
|
return ctxTarget.isOSVersionLT(major, minor, micro);
|
|
}
|
|
|
|
ModuleFile::ModuleFile(std::shared_ptr<const ModuleFileSharedCore> core)
|
|
: Core(core) {
|
|
assert(!core->hasError());
|
|
|
|
DeclTypeCursor = core->DeclTypeCursor;
|
|
SILCursor = core->SILCursor;
|
|
SILIndexCursor = core->SILIndexCursor;
|
|
DeclMemberTablesCursor = core->DeclMemberTablesCursor;
|
|
|
|
for (const auto &coreDep : core->Dependencies) {
|
|
Dependencies.emplace_back(coreDep);
|
|
}
|
|
|
|
// `ModuleFileSharedCore` has immutable data, we copy these into `ModuleFile`
|
|
// so we can mutate the arrays and replace the offsets with AST object
|
|
// pointers as we lazily deserialize them.
|
|
allocateBuffer(Decls, core->Decls);
|
|
allocateBuffer(LocalDeclContexts, core->LocalDeclContexts);
|
|
allocateBuffer(NormalConformances, core->NormalConformances);
|
|
allocateBuffer(SILLayouts, core->SILLayouts);
|
|
allocateBuffer(Types, core->Types);
|
|
allocateBuffer(ClangTypes, core->ClangTypes);
|
|
allocateBuffer(GenericSignatures, core->GenericSignatures);
|
|
allocateBuffer(SubstitutionMaps, core->SubstitutionMaps);
|
|
allocateBuffer(Identifiers, core->Identifiers);
|
|
}
|
|
|
|
bool ModuleFile::allowCompilerErrors() const {
|
|
return getContext().LangOpts.AllowModuleWithCompilerErrors;
|
|
}
|
|
|
|
Status ModuleFile::associateWithFileContext(FileUnit *file, SourceLoc diagLoc,
|
|
bool recoverFromIncompatibility) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
|
|
assert(!hasError() && "error already detected; should not call this");
|
|
assert(!FileContext && "already associated with an AST module");
|
|
FileContext = file;
|
|
Status status = Status::Valid;
|
|
|
|
ModuleDecl *M = file->getParentModule();
|
|
// The real (on-disk) name of the module should be checked here as that's the
|
|
// actually loaded module. In case module aliasing is used when building the main
|
|
// module, e.g. -module-name MyModule -module-alias Foo=Bar, the loaded module
|
|
// that maps to 'Foo' is actually Bar.swiftmodule|.swiftinterface (applies to swift
|
|
// modules only), which is retrieved via M->getRealName(). If no module aliasing is
|
|
// used, M->getRealName() will return the same value as M->getName(), which is 'Foo'.
|
|
if (M->getRealName().str() != Core->Name) {
|
|
return error(Status::NameMismatch);
|
|
}
|
|
|
|
ASTContext &ctx = getContext();
|
|
|
|
llvm::Triple moduleTarget(llvm::Triple::normalize(Core->TargetTriple));
|
|
if (!areCompatibleArchitectures(moduleTarget, ctx.LangOpts.Target) ||
|
|
!areCompatibleOSs(moduleTarget, ctx.LangOpts.Target)) {
|
|
status = Status::TargetIncompatible;
|
|
if (!recoverFromIncompatibility)
|
|
return error(status);
|
|
} else if (ctx.LangOpts.EnableTargetOSChecking && !M->isResilient() &&
|
|
isTargetTooNew(moduleTarget, ctx.LangOpts.Target)) {
|
|
status = Status::TargetTooNew;
|
|
if (!recoverFromIncompatibility)
|
|
return error(status);
|
|
}
|
|
|
|
StringRef moduleSDK = Core->SDKName;
|
|
StringRef clientSDK = ctx.LangOpts.SDKName;
|
|
if (ctx.SearchPathOpts.EnableSameSDKCheck &&
|
|
!moduleSDK.empty() && !clientSDK.empty() &&
|
|
moduleSDK != clientSDK) {
|
|
status = Status::SDKMismatch;
|
|
return error(status);
|
|
}
|
|
|
|
for (const auto &searchPath : Core->SearchPaths) {
|
|
ctx.addSearchPath(
|
|
ctx.SearchPathOpts.SearchPathRemapper.remapPath(searchPath.Path),
|
|
searchPath.IsFramework, searchPath.IsSystem);
|
|
}
|
|
|
|
auto clangImporter = static_cast<ClangImporter *>(ctx.getClangModuleLoader());
|
|
|
|
bool missingDependency = false;
|
|
for (auto &dependency : Dependencies) {
|
|
assert(!dependency.isLoaded() && "already loaded?");
|
|
|
|
if (dependency.isHeader()) {
|
|
// The path may be empty if the file being loaded is a partial AST,
|
|
// and the current compiler invocation is a merge-modules step.
|
|
if (!dependency.Core.RawPath.empty()) {
|
|
bool hadError =
|
|
clangImporter->importHeader(dependency.Core.RawPath,
|
|
file->getParentModule(),
|
|
Core->importedHeaderInfo.fileSize,
|
|
Core->importedHeaderInfo.fileModTime,
|
|
Core->importedHeaderInfo.contents,
|
|
diagLoc);
|
|
if (hadError)
|
|
return error(Status::FailedToLoadBridgingHeader);
|
|
}
|
|
ModuleDecl *importedHeaderModule = clangImporter->getImportedHeaderModule();
|
|
dependency.Import = ImportedModule{ImportPath::Access(),
|
|
importedHeaderModule};
|
|
continue;
|
|
}
|
|
|
|
// If this module file is being installed into the main module, it's treated
|
|
// as a partial module.
|
|
auto isPartialModule = M->isMainModule();
|
|
|
|
if (dependency.isImplementationOnly() &&
|
|
!(isPartialModule || ctx.LangOpts.DebuggerSupport)) {
|
|
// When building normally (and not merging partial modules), we don't
|
|
// want to bring in the implementation-only module, because that might
|
|
// change the set of visible declarations. However, when debugging we
|
|
// want to allow getting at the internals of this module when possible,
|
|
// and so we'll try to reference the implementation-only module if it's
|
|
// available.
|
|
continue;
|
|
}
|
|
|
|
ImportPath::Builder builder(ctx, dependency.Core.RawPath,
|
|
/*separator=*/'\0');
|
|
for (const auto &elem : builder) {
|
|
assert(!elem.Item.empty() && "invalid import path name");
|
|
}
|
|
|
|
auto importPath = builder.copyTo(ctx);
|
|
auto modulePath = importPath.getModulePath(dependency.isScoped());
|
|
auto accessPath = importPath.getAccessPath(dependency.isScoped());
|
|
|
|
auto module = getModule(modulePath, /*allowLoading*/true);
|
|
if (!module || module->failedToLoad()) {
|
|
// If we're missing the module we're an overlay for, treat that specially.
|
|
if (modulePath.size() == 1 &&
|
|
modulePath.front().Item == file->getParentModule()->getName()) {
|
|
return error(Status::MissingUnderlyingModule);
|
|
}
|
|
|
|
// Otherwise, continue trying to load dependencies, so that we can list
|
|
// everything that's missing.
|
|
if (!(dependency.isImplementationOnly() && ctx.LangOpts.DebuggerSupport))
|
|
missingDependency = true;
|
|
continue;
|
|
}
|
|
|
|
dependency.Import = ImportedModule{accessPath, module};
|
|
|
|
// SPI
|
|
StringRef spisStr = dependency.Core.RawSPIs;
|
|
while (!spisStr.empty()) {
|
|
StringRef nextComponent;
|
|
std::tie(nextComponent, spisStr) = spisStr.split('\0');
|
|
dependency.spiGroups.push_back(ctx.getIdentifier(nextComponent));
|
|
}
|
|
|
|
if (!module->hasResolvedImports()) {
|
|
// Notice that we check this condition /after/ recording the module that
|
|
// caused the problem. Clients need to be able to track down what the
|
|
// cycle was.
|
|
return error(Status::CircularDependency);
|
|
}
|
|
}
|
|
|
|
if (missingDependency) {
|
|
return error(Status::MissingDependency);
|
|
}
|
|
|
|
if (Core->Bits.HasEntryPoint) {
|
|
FileContext->getParentModule()->registerEntryPointFile(FileContext,
|
|
SourceLoc(),
|
|
None);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
bool ModuleFile::mayHaveDiagnosticsPointingAtBuffer() const {
|
|
if (!hasError())
|
|
return false;
|
|
|
|
// Today, the only buffer that might have diagnostics in them is the input
|
|
// buffer, and even then only if it has imported module contents.
|
|
return !Core->importedHeaderInfo.contents.empty();
|
|
}
|
|
|
|
ModuleFile::~ModuleFile() { }
|
|
|
|
void ModuleFile::lookupValue(DeclName name,
|
|
SmallVectorImpl<ValueDecl*> &results) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
|
|
if (Core->TopLevelDecls) {
|
|
// Find top-level declarations with the given name.
|
|
// FIXME: As a bit of a hack, do lookup by the simple name, then filter
|
|
// compound decls, to avoid having to completely redo how modules are
|
|
// serialized.
|
|
auto iter = Core->TopLevelDecls->find(name.getBaseName());
|
|
if (iter != Core->TopLevelDecls->end()) {
|
|
for (auto item : *iter) {
|
|
Expected<Decl *> declOrError = getDeclChecked(item.second);
|
|
if (!declOrError) {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(declOrError.takeError());
|
|
llvm::consumeError(declOrError.takeError());
|
|
continue;
|
|
}
|
|
auto VD = cast<ValueDecl>(declOrError.get());
|
|
if (name.isSimpleName() || VD->getName().matchesRef(name))
|
|
results.push_back(VD);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the name is an operator name, also look for operator methods.
|
|
if (name.isOperator() && Core->OperatorMethodDecls) {
|
|
auto iter = Core->OperatorMethodDecls->find(name.getBaseName());
|
|
if (iter != Core->OperatorMethodDecls->end()) {
|
|
for (auto item : *iter) {
|
|
Expected<Decl *> declOrError = getDeclChecked(item.second);
|
|
if (!declOrError) {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(declOrError.takeError());
|
|
llvm::consumeError(declOrError.takeError());
|
|
continue;
|
|
}
|
|
auto VD = cast<ValueDecl>(declOrError.get());
|
|
results.push_back(VD);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TypeDecl *ModuleFile::lookupLocalType(StringRef MangledName) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
|
|
if (!Core->LocalTypeDecls)
|
|
return nullptr;
|
|
|
|
auto iter = Core->LocalTypeDecls->find(MangledName);
|
|
if (iter == Core->LocalTypeDecls->end())
|
|
return nullptr;
|
|
|
|
return cast<TypeDecl>(getDecl(*iter));
|
|
}
|
|
|
|
std::unique_ptr<llvm::MemoryBuffer>
|
|
ModuleFile::getModuleName(ASTContext &Ctx, StringRef modulePath,
|
|
std::string &Name) {
|
|
// Open the module file
|
|
auto &fs = *Ctx.SourceMgr.getFileSystem();
|
|
auto moduleBuf = fs.getBufferForFile(modulePath);
|
|
if (!moduleBuf)
|
|
return nullptr;
|
|
|
|
// FIXME: This goes through the full cost of creating a ModuleFile object
|
|
// and then it keeps just the name and discards the whole object.
|
|
// The user of this API is `ExplicitSwiftModuleLoader`, this API should
|
|
// change to return a `ModuleFileSharedCore` object that
|
|
// `ExplicitSwiftModuleLoader` caches.
|
|
|
|
// Load the module file without validation.
|
|
std::unique_ptr<llvm::MemoryBuffer> newBuf =
|
|
llvm::MemoryBuffer::getMemBuffer(llvm::MemoryBufferRef(*moduleBuf.get()),
|
|
/*RequiresNullTerminator=*/false);
|
|
std::shared_ptr<const ModuleFileSharedCore> loadedModuleFile;
|
|
bool isFramework = false;
|
|
serialization::ValidationInfo loadInfo = ModuleFileSharedCore::load(
|
|
modulePath.str(), std::move(newBuf), nullptr, nullptr,
|
|
/*isFramework*/ isFramework, Ctx.SILOpts.EnableOSSAModules,
|
|
Ctx.SearchPathOpts.DeserializedPathRecoverer,
|
|
loadedModuleFile);
|
|
Name = loadedModuleFile->Name.str();
|
|
return std::move(moduleBuf.get());
|
|
}
|
|
|
|
OpaqueTypeDecl *ModuleFile::lookupOpaqueResultType(StringRef MangledName) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
|
|
if (!Core->OpaqueReturnTypeDecls)
|
|
return nullptr;
|
|
|
|
auto iter = Core->OpaqueReturnTypeDecls->find(MangledName);
|
|
if (iter == Core->OpaqueReturnTypeDecls->end())
|
|
return nullptr;
|
|
|
|
return cast<OpaqueTypeDecl>(getDecl(*iter));
|
|
}
|
|
|
|
TypeDecl *ModuleFile::lookupNestedType(Identifier name,
|
|
const NominalTypeDecl *parent) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
|
|
if (Core->NestedTypeDecls) {
|
|
auto iter = Core->NestedTypeDecls->find(name);
|
|
if (iter != Core->NestedTypeDecls->end()) {
|
|
for (std::pair<DeclID, DeclID> entry : *iter) {
|
|
assert(entry.first);
|
|
auto declOrOffset = Decls[entry.first - 1];
|
|
if (!declOrOffset.isComplete())
|
|
continue;
|
|
|
|
Decl *decl = declOrOffset;
|
|
if (decl != parent)
|
|
continue;
|
|
return cast<TypeDecl>(getDecl(entry.second));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!UnderlyingModule)
|
|
return nullptr;
|
|
|
|
for (FileUnit *file : UnderlyingModule->getFiles())
|
|
if (auto *nestedType = file->lookupNestedType(name, parent))
|
|
return nestedType;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
OperatorDecl *ModuleFile::lookupOperator(Identifier name,
|
|
OperatorFixity fixity) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
|
|
if (!Core->OperatorDecls)
|
|
return nullptr;
|
|
|
|
auto iter = Core->OperatorDecls->find(name);
|
|
if (iter == Core->OperatorDecls->end())
|
|
return nullptr;
|
|
|
|
for (auto item : *iter) {
|
|
if (getStableFixity(fixity) == item.first)
|
|
return cast<OperatorDecl>(getDecl(item.second));
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
PrecedenceGroupDecl *ModuleFile::lookupPrecedenceGroup(Identifier name) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
|
|
if (!Core->PrecedenceGroupDecls)
|
|
return nullptr;
|
|
|
|
auto iter = Core->PrecedenceGroupDecls->find(name);
|
|
if (iter == Core->PrecedenceGroupDecls->end())
|
|
return nullptr;
|
|
|
|
auto data = *iter;
|
|
assert(data.size() == 1);
|
|
return cast<PrecedenceGroupDecl>(getDecl(data[0].second));
|
|
}
|
|
|
|
void ModuleFile::getImportedModules(SmallVectorImpl<ImportedModule> &results,
|
|
ModuleDecl::ImportFilter filter) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
|
|
for (auto &dep : Dependencies) {
|
|
if (dep.isExported()) {
|
|
if (!filter.contains(ModuleDecl::ImportFilterKind::Exported))
|
|
continue;
|
|
|
|
} else if (dep.isImplementationOnly()) {
|
|
if (!filter.contains(ModuleDecl::ImportFilterKind::ImplementationOnly))
|
|
continue;
|
|
if (!dep.isLoaded()) {
|
|
// Pretend we didn't have this import if we weren't originally asked to
|
|
// load it.
|
|
continue;
|
|
}
|
|
|
|
} else {
|
|
if (!filter.contains(ModuleDecl::ImportFilterKind::Default))
|
|
continue;
|
|
}
|
|
|
|
assert(dep.isLoaded());
|
|
results.push_back(*(dep.Import));
|
|
}
|
|
}
|
|
|
|
void ModuleFile::getImportDecls(SmallVectorImpl<Decl *> &Results) {
|
|
if (!Bits.ComputedImportDecls) {
|
|
ASTContext &Ctx = getContext();
|
|
for (auto &Dep : Dependencies) {
|
|
// FIXME: We need a better way to show headers, since they usually /are/
|
|
// re-exported. This isn't likely to come up much, though.
|
|
if (Dep.isHeader())
|
|
continue;
|
|
|
|
ImportPath::Builder importPath(Ctx, Dep.Core.RawPath, /*separator=*/'\0');
|
|
|
|
if (importPath.size() == 1
|
|
&& importPath.front().Item == Ctx.StdlibModuleName)
|
|
continue;
|
|
|
|
auto modulePath = importPath.get().getModulePath(Dep.isScoped());
|
|
ModuleDecl *M = Ctx.getLoadedModule(modulePath);
|
|
|
|
auto Kind = ImportKind::Module;
|
|
if (Dep.isScoped()) {
|
|
auto ScopeID = importPath.get().getAccessPath(true).front().Item;
|
|
assert(!ScopeID.empty() &&
|
|
"invalid decl name (non-top-level decls not supported)");
|
|
|
|
if (!M) {
|
|
// The dependency module could not be loaded. Just make a guess
|
|
// about the import kind, we cannot do better.
|
|
Kind = ImportKind::Func;
|
|
} else {
|
|
// Lookup the decl in the top-level module.
|
|
ModuleDecl *TopLevelModule = M;
|
|
if (importPath.size() > 1)
|
|
TopLevelModule = Ctx.getLoadedModule(modulePath.getTopLevelPath());
|
|
|
|
SmallVector<ValueDecl *, 8> Decls;
|
|
TopLevelModule->lookupQualified(
|
|
TopLevelModule, DeclNameRef(ScopeID),
|
|
NL_QualifiedDefault, Decls);
|
|
Optional<ImportKind> FoundKind = ImportDecl::findBestImportKind(Decls);
|
|
assert(FoundKind.hasValue() &&
|
|
"deserialized imports should not be ambiguous");
|
|
Kind = *FoundKind;
|
|
}
|
|
}
|
|
|
|
auto *ID = ImportDecl::create(Ctx, FileContext, SourceLoc(), Kind,
|
|
SourceLoc(), importPath.get());
|
|
ID->setModule(M);
|
|
if (Dep.isExported())
|
|
ID->getAttrs().add(
|
|
new (Ctx) ExportedAttr(/*IsImplicit=*/false));
|
|
if (Dep.isImplementationOnly())
|
|
ID->getAttrs().add(
|
|
new (Ctx) ImplementationOnlyAttr(/*IsImplicit=*/false));
|
|
|
|
ImportDecls.push_back(ID);
|
|
}
|
|
Bits.ComputedImportDecls = true;
|
|
}
|
|
Results.append(ImportDecls.begin(), ImportDecls.end());
|
|
}
|
|
|
|
void ModuleFile::lookupVisibleDecls(ImportPath::Access accessPath,
|
|
VisibleDeclConsumer &consumer,
|
|
NLKind lookupKind) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
assert(accessPath.size() <= 1 && "can only refer to top-level decls");
|
|
|
|
if (!Core->TopLevelDecls)
|
|
return;
|
|
|
|
auto tryImport = [this, &consumer](DeclID ID) {
|
|
Expected<Decl *> declOrError = getDeclChecked(ID);
|
|
if (!declOrError) {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(declOrError.takeError());
|
|
llvm::consumeError(declOrError.takeError());
|
|
return;
|
|
}
|
|
consumer.foundDecl(cast<ValueDecl>(declOrError.get()),
|
|
DeclVisibilityKind::VisibleAtTopLevel);
|
|
};
|
|
|
|
if (!accessPath.empty()) {
|
|
auto iter = Core->TopLevelDecls->find(accessPath.front().Item);
|
|
if (iter == Core->TopLevelDecls->end())
|
|
return;
|
|
|
|
for (auto item : *iter)
|
|
tryImport(item.second);
|
|
|
|
return;
|
|
}
|
|
|
|
for (auto entry : Core->TopLevelDecls->data()) {
|
|
for (auto item : entry)
|
|
tryImport(item.second);
|
|
}
|
|
}
|
|
|
|
void ModuleFile::loadExtensions(NominalTypeDecl *nominal) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
if (!Core->ExtensionDecls)
|
|
return;
|
|
|
|
auto iter = Core->ExtensionDecls->find(nominal->getName());
|
|
if (iter == Core->ExtensionDecls->end())
|
|
return;
|
|
|
|
if (nominal->getEffectiveAccess() < AccessLevel::Internal) {
|
|
if (nominal->getModuleScopeContext() != getFile())
|
|
return;
|
|
}
|
|
|
|
if (nominal->getParent()->isModuleScopeContext()) {
|
|
auto parentFile = cast<FileUnit>(nominal->getParent());
|
|
StringRef moduleName = parentFile->getExportedModuleName();
|
|
|
|
for (auto item : *iter) {
|
|
if (item.first != moduleName)
|
|
continue;
|
|
Expected<Decl *> declOrError = getDeclChecked(item.second);
|
|
if (!declOrError) {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(declOrError.takeError());
|
|
llvm::consumeError(declOrError.takeError());
|
|
}
|
|
}
|
|
} else {
|
|
std::string mangledName =
|
|
Mangle::ASTMangler().mangleNominalType(nominal);
|
|
for (auto item : *iter) {
|
|
if (item.first != mangledName)
|
|
continue;
|
|
Expected<Decl *> declOrError = getDeclChecked(item.second);
|
|
if (!declOrError) {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(declOrError.takeError());
|
|
llvm::consumeError(declOrError.takeError());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModuleFile::loadObjCMethods(
|
|
ClassDecl *classDecl,
|
|
ObjCSelector selector,
|
|
bool isInstanceMethod,
|
|
llvm::TinyPtrVector<AbstractFunctionDecl *> &methods) {
|
|
// If we don't have an Objective-C method table, there's nothing to do.
|
|
if (!Core->ObjCMethods)
|
|
return;
|
|
|
|
// Look for all methods in the module file with this selector.
|
|
auto known = Core->ObjCMethods->find(selector);
|
|
if (known == Core->ObjCMethods->end()) {
|
|
return;
|
|
}
|
|
|
|
std::string ownerName = Mangle::ASTMangler().mangleNominalType(classDecl);
|
|
auto results = *known;
|
|
for (const auto &result : results) {
|
|
// If the method is the wrong kind (instance vs. class), skip it.
|
|
if (isInstanceMethod != std::get<1>(result))
|
|
continue;
|
|
|
|
// If the method isn't defined in the requested class, skip it.
|
|
if (std::get<0>(result) != ownerName)
|
|
continue;
|
|
|
|
// Deserialize the method and add it to the list.
|
|
if (auto func = dyn_cast_or_null<AbstractFunctionDecl>(
|
|
getDecl(std::get<2>(result)))) {
|
|
methods.push_back(func);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModuleFile::loadDerivativeFunctionConfigurations(
|
|
AbstractFunctionDecl *originalAFD,
|
|
llvm::SetVector<AutoDiffConfig> &results) {
|
|
if (!Core->DerivativeFunctionConfigurations)
|
|
return;
|
|
auto &ctx = originalAFD->getASTContext();
|
|
Mangle::ASTMangler Mangler;
|
|
auto mangledName = Mangler.mangleDeclAsUSR(originalAFD, "");
|
|
auto configs = Core->DerivativeFunctionConfigurations->find(mangledName);
|
|
if (configs == Core->DerivativeFunctionConfigurations->end())
|
|
return;
|
|
for (auto entry : *configs) {
|
|
auto *parameterIndices = IndexSubset::getFromString(ctx, entry.first);
|
|
auto derivativeGenSigOrError = getGenericSignatureChecked(entry.second);
|
|
if (!derivativeGenSigOrError) {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(derivativeGenSigOrError.takeError());
|
|
llvm::consumeError(derivativeGenSigOrError.takeError());
|
|
}
|
|
auto derivativeGenSig = derivativeGenSigOrError.get();
|
|
// NOTE(TF-1038): Result indices are currently unsupported in derivative
|
|
// registration attributes. In the meantime, always use `{0}` (wrt the
|
|
// first and only result).
|
|
auto resultIndices = IndexSubset::get(ctx, 1, {0});
|
|
results.insert({parameterIndices, resultIndices, derivativeGenSig});
|
|
}
|
|
}
|
|
|
|
Optional<Fingerprint>
|
|
ModuleFile::loadFingerprint(const IterableDeclContext *IDC) const {
|
|
PrettyStackTraceDecl trace("loading fingerprints for", IDC->getDecl());
|
|
|
|
assert(IDC->wasDeserialized());
|
|
assert(IDC->getDeclID() != 0);
|
|
|
|
if (!Core->DeclFingerprints) {
|
|
return None;
|
|
}
|
|
|
|
auto it = Core->DeclFingerprints->find(IDC->getDeclID());
|
|
if (it == Core->DeclFingerprints->end()) {
|
|
return None;
|
|
}
|
|
return *it;
|
|
}
|
|
|
|
TinyPtrVector<ValueDecl *>
|
|
ModuleFile::loadNamedMembers(const IterableDeclContext *IDC, DeclBaseName N,
|
|
uint64_t contextData) {
|
|
PrettyStackTraceDecl trace("loading members for", IDC->getDecl());
|
|
|
|
assert(IDC->wasDeserialized());
|
|
assert(Core->DeclMemberNames);
|
|
|
|
TinyPtrVector<ValueDecl *> results;
|
|
auto i = Core->DeclMemberNames->find(N);
|
|
if (i == Core->DeclMemberNames->end())
|
|
return results;
|
|
|
|
BitOffset subTableOffset = *i;
|
|
std::unique_ptr<SerializedDeclMembersTable> &subTable =
|
|
DeclMembersTables[subTableOffset];
|
|
if (!subTable) {
|
|
BCOffsetRAII restoreOffset(DeclMemberTablesCursor);
|
|
fatalIfNotSuccess(DeclMemberTablesCursor.JumpToBit(subTableOffset));
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclMemberTablesCursor.advance());
|
|
if (entry.Kind != llvm::BitstreamEntry::Record) {
|
|
fatal();
|
|
return results;
|
|
}
|
|
SmallVector<uint64_t, 64> scratch;
|
|
StringRef blobData;
|
|
unsigned kind = fatalIfUnexpected(
|
|
DeclMemberTablesCursor.readRecord(entry.ID, scratch, &blobData));
|
|
assert(kind == decl_member_tables_block::DECL_MEMBERS);
|
|
(void)kind;
|
|
subTable = Core->readDeclMembersTable(scratch, blobData);
|
|
}
|
|
|
|
assert(subTable);
|
|
auto j = subTable->find(IDC->getDeclID());
|
|
if (j != subTable->end()) {
|
|
for (DeclID d : *j) {
|
|
Expected<Decl *> mem = getDeclChecked(d);
|
|
if (mem) {
|
|
assert(mem.get() && "unchecked error deserializing named member");
|
|
if (auto MVD = dyn_cast<ValueDecl>(mem.get())) {
|
|
results.push_back(MVD);
|
|
}
|
|
} else {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(mem.takeError());
|
|
consumeError(mem.takeError());
|
|
}
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
void ModuleFile::lookupClassMember(ImportPath::Access accessPath,
|
|
DeclName name,
|
|
SmallVectorImpl<ValueDecl*> &results) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
assert(accessPath.size() <= 1 && "can only refer to top-level decls");
|
|
|
|
if (!Core->ClassMembersForDynamicLookup)
|
|
return;
|
|
|
|
auto iter = Core->ClassMembersForDynamicLookup->find(name.getBaseName());
|
|
if (iter == Core->ClassMembersForDynamicLookup->end())
|
|
return;
|
|
|
|
if (!accessPath.empty()) {
|
|
// As a hack to avoid completely redoing how the module is indexed, we take
|
|
// the simple-name-based lookup then filter by the compound name if we have
|
|
// one.
|
|
if (name.isSimpleName()) {
|
|
for (auto item : *iter) {
|
|
auto vd = cast<ValueDecl>(getDecl(item.second));
|
|
auto dc = vd->getDeclContext();
|
|
while (!dc->getParent()->isModuleScopeContext())
|
|
dc = dc->getParent();
|
|
if (auto nominal = dc->getSelfNominalTypeDecl())
|
|
if (nominal->getName() == accessPath.front().Item)
|
|
results.push_back(vd);
|
|
}
|
|
} else {
|
|
for (auto item : *iter) {
|
|
auto vd = cast<ValueDecl>(getDecl(item.second));
|
|
if (!vd->getName().matchesRef(name))
|
|
continue;
|
|
|
|
auto dc = vd->getDeclContext();
|
|
while (!dc->getParent()->isModuleScopeContext())
|
|
dc = dc->getParent();
|
|
if (auto nominal = dc->getSelfNominalTypeDecl())
|
|
if (nominal->getName() == accessPath.front().Item)
|
|
results.push_back(vd);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
for (auto item : *iter) {
|
|
auto vd = cast<ValueDecl>(getDecl(item.second));
|
|
results.push_back(vd);
|
|
}
|
|
}
|
|
|
|
void ModuleFile::lookupClassMembers(ImportPath::Access accessPath,
|
|
VisibleDeclConsumer &consumer) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
assert(accessPath.size() <= 1 && "can only refer to top-level decls");
|
|
|
|
if (!Core->ClassMembersForDynamicLookup)
|
|
return;
|
|
|
|
if (!accessPath.empty()) {
|
|
for (const auto &list : Core->ClassMembersForDynamicLookup->data()) {
|
|
for (auto item : list) {
|
|
auto decl = getDeclChecked(item.second);
|
|
if (!decl) {
|
|
llvm::consumeError(decl.takeError());
|
|
continue;
|
|
}
|
|
|
|
auto vd = cast<ValueDecl>(decl.get());
|
|
auto dc = vd->getDeclContext();
|
|
while (!dc->getParent()->isModuleScopeContext())
|
|
dc = dc->getParent();
|
|
if (auto nominal = dc->getSelfNominalTypeDecl())
|
|
if (nominal->getName() == accessPath.front().Item)
|
|
consumer.foundDecl(vd, DeclVisibilityKind::DynamicLookup,
|
|
DynamicLookupInfo::AnyObject);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
for (const auto &list : Core->ClassMembersForDynamicLookup->data()) {
|
|
for (auto item : list) {
|
|
auto decl = getDeclChecked(item.second);
|
|
if (!decl) {
|
|
llvm::consumeError(decl.takeError());
|
|
continue;
|
|
}
|
|
|
|
consumer.foundDecl(cast<ValueDecl>(decl.get()),
|
|
DeclVisibilityKind::DynamicLookup,
|
|
DynamicLookupInfo::AnyObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModuleFile::lookupObjCMethods(
|
|
ObjCSelector selector,
|
|
SmallVectorImpl<AbstractFunctionDecl *> &results) {
|
|
// If we don't have an Objective-C method table, there's nothing to do.
|
|
if (!Core->ObjCMethods) return;
|
|
|
|
// Look for all methods in the module file with this selector.
|
|
auto known = Core->ObjCMethods->find(selector);
|
|
if (known == Core->ObjCMethods->end()) return;
|
|
|
|
auto found = *known;
|
|
for (const auto &result : found) {
|
|
// Deserialize the method and add it to the list.
|
|
if (auto func = dyn_cast_or_null<AbstractFunctionDecl>(
|
|
getDecl(std::get<2>(result))))
|
|
results.push_back(func);
|
|
}
|
|
}
|
|
|
|
void ModuleFile::lookupImportedSPIGroups(
|
|
const ModuleDecl *importedModule,
|
|
llvm::SmallSetVector<Identifier, 4> &spiGroups) const {
|
|
for (auto &dep : Dependencies) {
|
|
auto depSpis = dep.spiGroups;
|
|
if (dep.Import.hasValue() && dep.Import->importedModule == importedModule &&
|
|
!depSpis.empty()) {
|
|
spiGroups.insert(depSpis.begin(), depSpis.end());
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ModuleFile::collectLinkLibraries(ModuleDecl::LinkLibraryCallback callback) const {
|
|
for (const auto &lib : Core->LinkLibraries)
|
|
callback(lib);
|
|
if (Core->Bits.IsFramework)
|
|
callback(LinkLibrary(Core->Name, LibraryKind::Framework));
|
|
}
|
|
|
|
void ModuleFile::getTopLevelDecls(
|
|
SmallVectorImpl<Decl *> &results,
|
|
llvm::function_ref<bool(DeclAttributes)> matchAttributes) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
for (DeclID entry : Core->OrderedTopLevelDecls) {
|
|
Expected<Decl *> declOrError = getDeclChecked(entry, matchAttributes);
|
|
if (!declOrError) {
|
|
if (declOrError.errorIsA<DeclAttributesDidNotMatch>()) {
|
|
// Decl rejected by matchAttributes, ignore it.
|
|
assert(matchAttributes);
|
|
consumeError(declOrError.takeError());
|
|
continue;
|
|
}
|
|
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(declOrError.takeError());
|
|
consumeError(declOrError.takeError());
|
|
continue;
|
|
}
|
|
results.push_back(declOrError.get());
|
|
}
|
|
}
|
|
|
|
void ModuleFile::getExportedPrespecializations(
|
|
SmallVectorImpl<Decl *> &results) {
|
|
for (DeclID entry : Core->ExportedPrespecializationDecls) {
|
|
Expected<Decl *> declOrError = getDeclChecked(entry);
|
|
if (!declOrError) {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(declOrError.takeError());
|
|
consumeError(declOrError.takeError());
|
|
continue;
|
|
}
|
|
results.push_back(declOrError.get());
|
|
}
|
|
}
|
|
|
|
void ModuleFile::getOperatorDecls(SmallVectorImpl<OperatorDecl *> &results) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
if (!Core->OperatorDecls)
|
|
return;
|
|
|
|
for (auto entry : Core->OperatorDecls->data()) {
|
|
for (auto item : entry)
|
|
results.push_back(cast<OperatorDecl>(getDecl(item.second)));
|
|
}
|
|
}
|
|
|
|
void ModuleFile::getPrecedenceGroups(
|
|
SmallVectorImpl<PrecedenceGroupDecl*> &results) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
if (Core->PrecedenceGroupDecls) {
|
|
for (auto entry : Core->PrecedenceGroupDecls->data()) {
|
|
for (auto item : entry)
|
|
results.push_back(cast<PrecedenceGroupDecl>(getDecl(item.second)));
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ModuleFile::getLocalTypeDecls(SmallVectorImpl<TypeDecl *> &results) {
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
if (!Core->LocalTypeDecls)
|
|
return;
|
|
|
|
for (auto DeclID : Core->LocalTypeDecls->data()) {
|
|
auto TD = cast<TypeDecl>(getDecl(DeclID));
|
|
results.push_back(TD);
|
|
}
|
|
}
|
|
|
|
void
|
|
ModuleFile::getOpaqueReturnTypeDecls(SmallVectorImpl<OpaqueTypeDecl *> &results)
|
|
{
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
if (!Core->OpaqueReturnTypeDecls)
|
|
return;
|
|
|
|
for (auto DeclID : Core->OpaqueReturnTypeDecls->data()) {
|
|
auto TD = cast<OpaqueTypeDecl>(getDecl(DeclID));
|
|
results.push_back(TD);
|
|
}
|
|
}
|
|
|
|
void ModuleFile::getDisplayDecls(SmallVectorImpl<Decl *> &results) {
|
|
if (UnderlyingModule)
|
|
UnderlyingModule->getDisplayDecls(results);
|
|
|
|
PrettyStackTraceModuleFile stackEntry(*this);
|
|
getImportDecls(results);
|
|
getTopLevelDecls(results);
|
|
}
|
|
|
|
Optional<CommentInfo> ModuleFile::getCommentForDecl(const Decl *D) const {
|
|
assert(D);
|
|
|
|
// Keep these as assertions instead of early exits to ensure that we are not
|
|
// doing extra work. These cases should be handled by clients of this API.
|
|
assert(!D->hasClangNode() &&
|
|
"cannot find comments for Clang decls in Swift modules");
|
|
assert(D->getDeclContext()->getModuleScopeContext() == FileContext &&
|
|
"Decl is from a different serialized file");
|
|
|
|
if (!Core->DeclCommentTable)
|
|
return None;
|
|
if (D->isImplicit())
|
|
return None;
|
|
// Compute the USR.
|
|
llvm::SmallString<128> USRBuffer;
|
|
llvm::raw_svector_ostream OS(USRBuffer);
|
|
if (ide::printDeclUSR(D, OS))
|
|
return None;
|
|
|
|
return getCommentForDeclByUSR(USRBuffer.str());
|
|
}
|
|
|
|
void ModuleFile::collectSerializedSearchPath(
|
|
llvm::function_ref<void(StringRef)> callback) const {
|
|
for (auto path: Core->SearchPaths) {
|
|
callback(path.Path);
|
|
}
|
|
}
|
|
|
|
void ModuleFile::collectBasicSourceFileInfo(
|
|
llvm::function_ref<void(const BasicSourceFileInfo &)> callback) const {
|
|
if (Core->SourceFileListData.empty())
|
|
return;
|
|
assert(!Core->SourceLocsTextData.empty());
|
|
|
|
auto *Cursor = Core->SourceFileListData.bytes_begin();
|
|
auto *End = Core->SourceFileListData.bytes_end();
|
|
while (Cursor < End) {
|
|
// FilePath (byte offset in 'SourceLocsTextData').
|
|
auto fileID = endian::readNext<uint32_t, little, unaligned>(Cursor);
|
|
|
|
// InterfaceHashIncludingTypeMembers (fixed length string).
|
|
auto fpStrIncludingTypeMembers = StringRef{reinterpret_cast<const char *>(Cursor),
|
|
Fingerprint::DIGEST_LENGTH};
|
|
Cursor += Fingerprint::DIGEST_LENGTH;
|
|
|
|
// InterfaceHashExcludingTypeMembers (fixed length string).
|
|
auto fpStrExcludingTypeMembers = StringRef{reinterpret_cast<const char *>(Cursor),
|
|
Fingerprint::DIGEST_LENGTH};
|
|
Cursor += Fingerprint::DIGEST_LENGTH;
|
|
|
|
// LastModified (nanoseconds since epoch).
|
|
auto timestamp = endian::readNext<uint64_t, little, unaligned>(Cursor);
|
|
// FileSize (num of bytes).
|
|
auto fileSize = endian::readNext<uint64_t, little, unaligned>(Cursor);
|
|
|
|
assert(fileID < Core->SourceLocsTextData.size());
|
|
auto filePath = Core->SourceLocsTextData.substr(fileID);
|
|
size_t terminatorOffset = filePath.find('\0');
|
|
filePath = filePath.slice(0, terminatorOffset);
|
|
|
|
auto fingerprintIncludingTypeMembers =
|
|
Fingerprint::fromString(fpStrIncludingTypeMembers);
|
|
if (!fingerprintIncludingTypeMembers) {
|
|
llvm::errs() << "Unconvertible fingerprint including type members'"
|
|
<< fpStrIncludingTypeMembers << "'\n";
|
|
abort();
|
|
}
|
|
auto fingerprintExcludingTypeMembers =
|
|
Fingerprint::fromString(fpStrExcludingTypeMembers);
|
|
if (!fingerprintExcludingTypeMembers) {
|
|
llvm::errs() << "Unconvertible fingerprint excluding type members'"
|
|
<< fpStrExcludingTypeMembers << "'\n";
|
|
abort();
|
|
}
|
|
callback(BasicSourceFileInfo(filePath,
|
|
fingerprintIncludingTypeMembers.getValue(),
|
|
fingerprintExcludingTypeMembers.getValue(),
|
|
llvm::sys::TimePoint<>(std::chrono::nanoseconds(timestamp)),
|
|
fileSize));
|
|
}
|
|
}
|
|
|
|
static StringRef readLocString(const char *&Data, StringRef StringData) {
|
|
auto Str =
|
|
StringData.substr(endian::readNext<uint32_t, little, unaligned>(Data));
|
|
size_t TerminatorOffset = Str.find('\0');
|
|
assert(TerminatorOffset != StringRef::npos && "unterminated string data");
|
|
return Str.slice(0, TerminatorOffset);
|
|
}
|
|
|
|
static void readRawLoc(ExternalSourceLocs::RawLoc &Loc, const char *&Data,
|
|
StringRef StringData) {
|
|
Loc.Offset = endian::readNext<uint32_t, little, unaligned>(Data);
|
|
Loc.Line = endian::readNext<uint32_t, little, unaligned>(Data);
|
|
Loc.Column = endian::readNext<uint32_t, little, unaligned>(Data);
|
|
|
|
Loc.Directive.Offset = endian::readNext<uint32_t, little, unaligned>(Data);
|
|
Loc.Directive.LineOffset = endian::readNext<int32_t, little, unaligned>(Data);
|
|
Loc.Directive.Length = endian::readNext<uint32_t, little, unaligned>(Data);
|
|
Loc.Directive.Name = readLocString(Data, StringData);
|
|
}
|
|
|
|
Optional<ExternalSourceLocs::RawLocs>
|
|
ModuleFile::getExternalRawLocsForDecl(const Decl *D) const {
|
|
assert(D);
|
|
// Keep these as assertions instead of early exits to ensure that we are not
|
|
// doing extra work. These cases should be handled by clients of this API.
|
|
assert(!D->hasClangNode() &&
|
|
"cannot find comments for Clang decls in Swift modules");
|
|
assert(D->getDeclContext()->getModuleScopeContext() == FileContext &&
|
|
"Decl is from a different serialized file");
|
|
|
|
if (!Core->DeclUSRsTable)
|
|
return None;
|
|
// Future compilers may not provide BasicDeclLocsData anymore.
|
|
if (Core->BasicDeclLocsData.empty())
|
|
return None;
|
|
if (D->isImplicit())
|
|
return None;
|
|
|
|
// Compute the USR.
|
|
llvm::SmallString<128> USRBuffer;
|
|
llvm::raw_svector_ostream OS(USRBuffer);
|
|
if (ide::printDeclUSR(D, OS))
|
|
return None;
|
|
|
|
auto It = Core->DeclUSRsTable->find(OS.str());
|
|
if (It == Core->DeclUSRsTable->end())
|
|
return None;
|
|
|
|
auto UsrId = *It;
|
|
uint32_t RecordSize =
|
|
4 + // Source filename offset
|
|
4 + // Doc ranges offset
|
|
4 * 3 * 7; // Loc/StartLoc/EndLoc each have 7 4-byte fields
|
|
uint32_t RecordOffset = RecordSize * UsrId;
|
|
assert(RecordOffset < Core->BasicDeclLocsData.size());
|
|
assert(Core->BasicDeclLocsData.size() % RecordSize == 0);
|
|
auto *Record = Core->BasicDeclLocsData.data() + RecordOffset;
|
|
|
|
ExternalSourceLocs::RawLocs Result;
|
|
Result.SourceFilePath = readLocString(Record, Core->SourceLocsTextData);
|
|
|
|
const auto DocRangesOffset =
|
|
endian::readNext<uint32_t, little, unaligned>(Record);
|
|
if (DocRangesOffset) {
|
|
assert(!Core->DocRangesData.empty());
|
|
const auto *Data = Core->DocRangesData.data() + DocRangesOffset;
|
|
const auto NumLocs = endian::readNext<uint32_t, little, unaligned>(Data);
|
|
assert(NumLocs);
|
|
|
|
for (uint32_t I = 0; I < NumLocs; ++I) {
|
|
auto &Range =
|
|
Result.DocRanges.emplace_back(ExternalSourceLocs::RawLoc(), 0);
|
|
readRawLoc(Range.first, Data, Core->SourceLocsTextData);
|
|
Range.second = endian::readNext<uint32_t, little, unaligned>(Data);
|
|
}
|
|
}
|
|
|
|
readRawLoc(Result.Loc, Record, Core->SourceLocsTextData);
|
|
readRawLoc(Result.StartLoc, Record, Core->SourceLocsTextData);
|
|
readRawLoc(Result.EndLoc, Record, Core->SourceLocsTextData);
|
|
return Result;
|
|
}
|
|
|
|
const static StringRef Separator = "/";
|
|
|
|
Optional<StringRef> ModuleFile::getGroupNameById(unsigned Id) const {
|
|
if (!Core->GroupNamesMap)
|
|
return None;
|
|
const auto &GroupNamesMap = *Core->GroupNamesMap;
|
|
auto it = GroupNamesMap.find(Id);
|
|
if (it == GroupNamesMap.end())
|
|
return None;
|
|
StringRef Original = it->second;
|
|
if (Original.empty())
|
|
return None;
|
|
auto SepPos = Original.find_last_of(Separator);
|
|
assert(SepPos != StringRef::npos && "Cannot find Separator.");
|
|
return StringRef(Original.data(), SepPos);
|
|
}
|
|
|
|
Optional<StringRef> ModuleFile::getSourceFileNameById(unsigned Id) const {
|
|
if (!Core->GroupNamesMap)
|
|
return None;
|
|
const auto &GroupNamesMap = *Core->GroupNamesMap;
|
|
auto it = GroupNamesMap.find(Id);
|
|
if (it == GroupNamesMap.end())
|
|
return None;
|
|
StringRef Original = it->second;
|
|
if (Original.empty())
|
|
return None;
|
|
auto SepPos = Original.find_last_of(Separator);
|
|
assert(SepPos != StringRef::npos && "Cannot find Separator.");
|
|
auto Start = Original.data() + SepPos + 1;
|
|
auto Len = Original.size() - SepPos - 1;
|
|
return StringRef(Start, Len);
|
|
}
|
|
|
|
Optional<StringRef> ModuleFile::getGroupNameForDecl(const Decl *D) const {
|
|
auto Triple = getCommentForDecl(D);
|
|
if (!Triple.hasValue()) {
|
|
return None;
|
|
}
|
|
return getGroupNameById(Triple.getValue().Group);
|
|
}
|
|
|
|
|
|
Optional<StringRef>
|
|
ModuleFile::getSourceFileNameForDecl(const Decl *D) const {
|
|
auto Triple = getCommentForDecl(D);
|
|
if (!Triple.hasValue()) {
|
|
return None;
|
|
}
|
|
return getSourceFileNameById(Triple.getValue().Group);
|
|
}
|
|
|
|
Optional<unsigned>
|
|
ModuleFile::getSourceOrderForDecl(const Decl *D) const {
|
|
auto Triple = getCommentForDecl(D);
|
|
if (!Triple.hasValue()) {
|
|
return None;
|
|
}
|
|
return Triple.getValue().SourceOrder;
|
|
}
|
|
|
|
void ModuleFile::collectAllGroups(SmallVectorImpl<StringRef> &Names) const {
|
|
if (!Core->GroupNamesMap)
|
|
return;
|
|
for (auto It = Core->GroupNamesMap->begin(); It != Core->GroupNamesMap->end();
|
|
++It) {
|
|
StringRef FullGroupName = It->getSecond();
|
|
if (FullGroupName.empty())
|
|
continue;
|
|
auto Sep = FullGroupName.find_last_of(Separator);
|
|
assert(Sep != StringRef::npos);
|
|
auto Group = FullGroupName.substr(0, Sep);
|
|
auto Found = std::find(Names.begin(), Names.end(), Group);
|
|
if (Found != Names.end())
|
|
continue;
|
|
Names.push_back(Group);
|
|
}
|
|
}
|
|
|
|
Optional<CommentInfo>
|
|
ModuleFile::getCommentForDeclByUSR(StringRef USR) const {
|
|
if (!Core->DeclCommentTable)
|
|
return None;
|
|
|
|
// Use the comment cache to preserve the memory that the array of
|
|
// `SingleRawComment`s, inside `CommentInfo`, points to, and generally avoid
|
|
// allocating memory every time we query `Core->DeclCommentTable`.
|
|
auto it = CommentsCache.find(USR);
|
|
if (it != CommentsCache.end()) {
|
|
const auto &cachePtr = it->second;
|
|
if (!cachePtr)
|
|
return None;
|
|
return cachePtr->Info;
|
|
}
|
|
|
|
auto I = Core->DeclCommentTable->find(USR);
|
|
if (I == Core->DeclCommentTable->end())
|
|
return None;
|
|
|
|
auto &cachePtr = CommentsCache[USR];
|
|
cachePtr = *I;
|
|
return cachePtr->Info;
|
|
}
|
|
|
|
Optional<StringRef>
|
|
ModuleFile::getGroupNameByUSR(StringRef USR) const {
|
|
if (auto Comment = getCommentForDeclByUSR(USR)) {
|
|
return getGroupNameById(Comment.getValue().Group);
|
|
}
|
|
return None;
|
|
}
|
|
|
|
Identifier ModuleFile::getDiscriminatorForPrivateValue(const ValueDecl *D) {
|
|
Identifier discriminator = PrivateDiscriminatorsByValue.lookup(D);
|
|
assert(!discriminator.empty() && "no discriminator found for decl");
|
|
return discriminator;
|
|
}
|
|
|
|
void ModuleFile::verify() const {
|
|
#ifndef NDEBUG
|
|
const auto &Context = getContext();
|
|
for (const Serialized<Decl*> &next : Decls)
|
|
if (next.isComplete() && swift::shouldVerify(next, Context))
|
|
swift::verify(next);
|
|
#endif
|
|
}
|
|
|
|
bool SerializedASTFile::hasEntryPoint() const {
|
|
return File.hasEntryPoint();
|
|
}
|
|
|
|
bool SerializedASTFile::getAllGenericSignatures(
|
|
SmallVectorImpl<GenericSignature> &genericSignatures) {
|
|
genericSignatures.clear();
|
|
for (unsigned index : indices(File.GenericSignatures)) {
|
|
if (auto genericSig = File.getGenericSignature(index + 1))
|
|
genericSignatures.push_back(genericSig);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
ValueDecl *SerializedASTFile::getMainDecl() const {
|
|
assert(hasEntryPoint());
|
|
return cast_or_null<ValueDecl>(File.getDecl(File.getEntryPointDeclID()));
|
|
}
|
|
|
|
const version::Version &SerializedASTFile::getLanguageVersionBuiltWith() const {
|
|
return File.getCompatibilityVersion();
|
|
}
|
|
|
|
StringRef SerializedASTFile::getModuleDefiningPath() const {
|
|
StringRef moduleFilename = getFilename();
|
|
StringRef parentDir = llvm::sys::path::parent_path(moduleFilename);
|
|
|
|
if (llvm::sys::path::extension(parentDir) == ".swiftmodule")
|
|
return parentDir;
|
|
|
|
return moduleFilename;
|
|
}
|