mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
175d0ba8e6
Clarify the sources of information when a conformance reference in a swiftmodule doesn't match with the requirements seen by the reader.
9594 lines
334 KiB
C++
9594 lines
334 KiB
C++
//===--- Deserialization.cpp - Loading a serialized AST -------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2025 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 "BCReadingExtras.h"
|
|
#include "DeserializationErrors.h"
|
|
#include "ModuleFile.h"
|
|
#include "ModuleFormat.h"
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/Attr.h"
|
|
#include "swift/AST/AttrKind.h"
|
|
#include "swift/AST/AutoDiff.h"
|
|
#include "swift/AST/ConformanceLookup.h"
|
|
#include "swift/AST/DiagnosticsSema.h"
|
|
#include "swift/AST/DistributedDecl.h"
|
|
#include "swift/AST/Expr.h"
|
|
#include "swift/AST/ForeignAsyncConvention.h"
|
|
#include "swift/AST/ForeignErrorConvention.h"
|
|
#include "swift/AST/GenericEnvironment.h"
|
|
#include "swift/AST/Initializer.h"
|
|
#include "swift/AST/MacroDefinition.h"
|
|
#include "swift/AST/NameLookupRequests.h"
|
|
#include "swift/AST/PackConformance.h"
|
|
#include "swift/AST/ParameterList.h"
|
|
#include "swift/AST/Pattern.h"
|
|
#include "swift/AST/PrettyStackTrace.h"
|
|
#include "swift/AST/PropertyWrappers.h"
|
|
#include "swift/AST/ProtocolConformance.h"
|
|
#include "swift/AST/TypeCheckRequests.h"
|
|
#include "swift/Basic/Assertions.h"
|
|
#include "swift/Basic/Defer.h"
|
|
#include "swift/Basic/Statistic.h"
|
|
#include "swift/ClangImporter/ClangImporter.h"
|
|
#include "swift/ClangImporter/ClangModule.h"
|
|
#include "swift/ClangImporter/SwiftAbstractBasicReader.h"
|
|
#include "swift/Serialization/SerializedModuleLoader.h"
|
|
#include "clang/AST/DeclTemplate.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "clang/Basic/SourceManager.h"
|
|
#include "clang/Basic/AttributeCommonInfo.h"
|
|
#include "clang/Index/USRGeneration.h"
|
|
#include "llvm/ADT/Statistic.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/Error.h"
|
|
#include "llvm/Support/Signals.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#define DEBUG_TYPE "Serialization"
|
|
|
|
// Unwrap an Expected<> variable following the typical deserialization pattern:
|
|
// - On a value, assign it to Output.
|
|
// - On an error, return it to bubble it up to the caller.
|
|
#define SET_OR_RETURN_ERROR(Output, Input) { \
|
|
auto ValueOrError = Input; \
|
|
if (!ValueOrError) \
|
|
return ValueOrError.takeError(); \
|
|
Output = ValueOrError.get(); \
|
|
}
|
|
|
|
STATISTIC(NumDeclsLoaded, "# of decls deserialized");
|
|
STATISTIC(NumMemberListsLoaded,
|
|
"# of nominals/extensions whose members were loaded");
|
|
STATISTIC(NumNormalProtocolConformancesLoaded,
|
|
"# of normal protocol conformances deserialized");
|
|
STATISTIC(NumNormalProtocolConformancesCompleted,
|
|
"# of normal protocol conformances completed");
|
|
STATISTIC(NumOpaqueTypeDeclsCompleted,
|
|
"# of opaque type declarations completed");
|
|
STATISTIC(NumNestedTypeShortcuts,
|
|
"# of nested types resolved without full lookup");
|
|
|
|
using namespace swift;
|
|
using namespace swift::serialization;
|
|
using llvm::Expected;
|
|
|
|
namespace {
|
|
struct DeclAndOffset {
|
|
const Decl *D;
|
|
uint64_t offset;
|
|
};
|
|
|
|
static raw_ostream &operator<<(raw_ostream &os, DeclAndOffset &&pair) {
|
|
return os << Decl::getKindName(pair.D->getKind())
|
|
<< "Decl @ " << pair.offset;
|
|
}
|
|
|
|
class PrettyDeclDeserialization : public llvm::PrettyStackTraceEntry {
|
|
const ModuleFile *MF;
|
|
const ModuleFile::Serialized<Decl*> &DeclOrOffset;
|
|
uint64_t offset;
|
|
decls_block::RecordKind Kind;
|
|
public:
|
|
PrettyDeclDeserialization(ModuleFile *module,
|
|
const ModuleFile::Serialized<Decl*> &declOrOffset,
|
|
decls_block::RecordKind kind)
|
|
: MF(module), DeclOrOffset(declOrOffset), offset(declOrOffset),
|
|
Kind(kind) {
|
|
}
|
|
|
|
static const char *getRecordKindString(decls_block::RecordKind Kind) {
|
|
switch (Kind) {
|
|
#define RECORD(Id) case decls_block::Id: return #Id;
|
|
#include "DeclTypeRecordNodes.def"
|
|
}
|
|
|
|
llvm_unreachable("Unhandled RecordKind in switch.");
|
|
}
|
|
|
|
void print(raw_ostream &os) const override {
|
|
if (!DeclOrOffset.isComplete()) {
|
|
os << "While deserializing decl @ " << offset << " ("
|
|
<< getRecordKindString(Kind) << ")";
|
|
} else {
|
|
os << "While deserializing ";
|
|
|
|
if (auto VD = dyn_cast<ValueDecl>(DeclOrOffset.get())) {
|
|
os << "'" << VD->getBaseName() << "' (" << DeclAndOffset{VD, offset}
|
|
<< ")";
|
|
} else if (auto ED = dyn_cast<ExtensionDecl>(DeclOrOffset.get())) {
|
|
os << "extension of '" << ED->getExtendedType() << "' ("
|
|
<< DeclAndOffset{ED, offset} << ")";
|
|
} else {
|
|
os << DeclAndOffset{DeclOrOffset.get(), offset};
|
|
}
|
|
}
|
|
os << " in '" << MF->getName() << "'\n";
|
|
}
|
|
};
|
|
|
|
class PrettySupplementalDeclNameTrace : public llvm::PrettyStackTraceEntry {
|
|
DeclName name;
|
|
public:
|
|
PrettySupplementalDeclNameTrace(DeclName name)
|
|
: name(name) { }
|
|
|
|
void print(raw_ostream &os) const override {
|
|
os << " ...decl is named '" << name << "'\n";
|
|
}
|
|
};
|
|
|
|
class PrettyXRefTrace :
|
|
public llvm::PrettyStackTraceEntry,
|
|
public XRefTracePath {
|
|
public:
|
|
explicit PrettyXRefTrace(ModuleDecl &M) : XRefTracePath(M) {}
|
|
|
|
void print(raw_ostream &os) const override {
|
|
XRefTracePath::print(os, "\t");
|
|
}
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
const char DeclDeserializationError::ID = '\0';
|
|
void DeclDeserializationError::anchor() {}
|
|
const char XRefError::ID = '\0';
|
|
void XRefError::anchor() {}
|
|
const char XRefNonLoadedModuleError::ID = '\0';
|
|
void XRefNonLoadedModuleError::anchor() {}
|
|
const char OverrideError::ID = '\0';
|
|
void OverrideError::anchor() {}
|
|
const char TypeError::ID = '\0';
|
|
void TypeError::anchor() {}
|
|
const char ExtensionError::ID = '\0';
|
|
void ExtensionError::anchor() {}
|
|
const char DeclAttributesDidNotMatch::ID = '\0';
|
|
void DeclAttributesDidNotMatch::anchor() {}
|
|
const char InvalidRecordKindError::ID = '\0';
|
|
void InvalidRecordKindError::anchor() {}
|
|
const char UnsafeDeserializationError::ID = '\0';
|
|
void UnsafeDeserializationError::anchor() {}
|
|
const char ModularizationError::ID = '\0';
|
|
void ModularizationError::anchor() {}
|
|
const char InvalidEnumValueError::ID = '\0';
|
|
void InvalidEnumValueError::anchor() {}
|
|
const char ConformanceXRefError::ID = '\0';
|
|
void ConformanceXRefError::anchor() {}
|
|
const char InvalidAvailabilityDomainError::ID = '\0';
|
|
void InvalidAvailabilityDomainError::anchor() {}
|
|
|
|
/// Skips a single record in the bitstream.
|
|
///
|
|
/// Destroys the stream position if the next entry is not a record.
|
|
static void skipRecord(llvm::BitstreamCursor &cursor, unsigned recordKind) {
|
|
auto next = llvm::cantFail<llvm::BitstreamEntry>(
|
|
cursor.advance(AF_DontPopBlockAtEnd));
|
|
assert(next.Kind == llvm::BitstreamEntry::Record);
|
|
|
|
unsigned kind = llvm::cantFail<unsigned>(cursor.skipRecord(next.ID));
|
|
assert(kind == recordKind);
|
|
(void)kind;
|
|
}
|
|
|
|
char FatalDeserializationError::ID;
|
|
|
|
void ModuleFile::fatal(llvm::Error error) const {
|
|
Core->fatal(diagnoseFatal(std::move(error)));
|
|
}
|
|
|
|
SourceLoc ModuleFile::getSourceLoc() const {
|
|
auto &SourceMgr = getContext().Diags.SourceMgr;
|
|
auto filename = getModuleFilename();
|
|
auto bufferID = SourceMgr.getIDForBufferIdentifier(filename);
|
|
if (!bufferID)
|
|
bufferID = SourceMgr.addMemBufferCopy("<binary format>", filename);
|
|
return SourceMgr.getLocForBufferStart(*bufferID);
|
|
}
|
|
|
|
SourceLoc ModularizationError::getSourceLoc() const {
|
|
auto &SourceMgr = referenceModule->getContext().Diags.SourceMgr;
|
|
auto filename = referenceModule->getModuleFilename();
|
|
|
|
// Synthesize some context. We don't have an actual decl here
|
|
// so try to print a simple representation of the reference.
|
|
std::string S;
|
|
llvm::raw_string_ostream OS(S);
|
|
OS << expectedModule->getName() << "." << name;
|
|
|
|
// If we enable these remarks by default we may want to reuse these buffers.
|
|
auto bufferID = SourceMgr.addMemBufferCopy(S, filename);
|
|
return SourceMgr.getLocForBufferStart(bufferID);
|
|
}
|
|
|
|
void
|
|
ModularizationError::diagnose(const ModuleFile *MF,
|
|
DiagnosticBehavior limit) const {
|
|
auto &ctx = MF->getContext();
|
|
auto loc = getSourceLoc();
|
|
|
|
auto diagnoseError = [&](Kind errorKind) {
|
|
switch (errorKind) {
|
|
case Kind::DeclMoved:
|
|
return ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_decl_moved,
|
|
declIsType, name, expectedModule,
|
|
foundModule);
|
|
case Kind::DeclKindChanged:
|
|
return
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_decl_type_changed,
|
|
declIsType, name, expectedModule,
|
|
referenceModule->getName(), foundModule,
|
|
foundModule != expectedModule);
|
|
case Kind::DeclNotFound:
|
|
return ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_decl_not_found,
|
|
declIsType, name, expectedModule);
|
|
}
|
|
llvm_unreachable("Unhandled ModularizationError::Kind in switch.");
|
|
};
|
|
|
|
diagnoseError(errorKind).limitBehavior(limit);
|
|
|
|
// We could pass along the `path` information through notes.
|
|
// However, for a top-level decl a path would just duplicate the
|
|
// expected module name and the decl name from the diagnostic.
|
|
|
|
// Show context with relevant file paths.
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_note_expected,
|
|
declIsType, expectedModule,
|
|
expectedModule->getModuleSourceFilename());
|
|
|
|
const clang::Module *expectedUnderlying =
|
|
expectedModule->findUnderlyingClangModule();
|
|
if (!expectedModule->isNonSwiftModule() &&
|
|
expectedUnderlying) {
|
|
auto CML = ctx.getClangModuleLoader();
|
|
auto &CSM = CML->getClangASTContext().getSourceManager();
|
|
StringRef filename = CSM.getFilename(expectedUnderlying->DefinitionLoc);
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_note_expected_underlying,
|
|
expectedUnderlying->Name,
|
|
filename);
|
|
}
|
|
|
|
if (foundModule)
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_note_found,
|
|
declIsType, foundModule,
|
|
foundModule->getModuleSourceFilename());
|
|
|
|
if (mismatchingTypes.has_value()) {
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_type_mismatch,
|
|
mismatchingTypes->first, mismatchingTypes->second);
|
|
}
|
|
|
|
// A Swift language version mismatch could lead to a different set of rules
|
|
// from APINotes files being applied when building the module vs when reading
|
|
// from it.
|
|
version::Version
|
|
moduleLangVersion = referenceModule->getCompatibilityVersion(),
|
|
clientLangVersion = MF->getContext().LangOpts.EffectiveLanguageVersion;
|
|
ModuleDecl *referenceModuleDecl = referenceModule->getAssociatedModule();
|
|
if (clientLangVersion != moduleLangVersion) {
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_swift_version,
|
|
referenceModuleDecl, moduleLangVersion,
|
|
clientLangVersion);
|
|
}
|
|
|
|
// If the error is in a resilient swiftmodule adjacent to a swiftinterface,
|
|
// deleting the module to rebuild from the swiftinterface may fix the issue.
|
|
// Limit this suggestion to distributed Swift modules to not hint at
|
|
// deleting local caches and such.
|
|
bool referenceModuleIsDistributed = referenceModuleDecl &&
|
|
referenceModuleDecl->isNonUserModule();
|
|
if (referenceModule->getResilienceStrategy() ==
|
|
ResilienceStrategy::Resilient &&
|
|
referenceModuleIsDistributed) {
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_stale_module,
|
|
referenceModuleDecl,
|
|
referenceModule->getModuleFilename());
|
|
}
|
|
|
|
// If the missing decl was expected to be in a clang module,
|
|
// it may be hidden by some clang defined passed via `-Xcc` affecting how
|
|
// headers are seen.
|
|
if (expectedUnderlying) {
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_audit_headers,
|
|
expectedModule->isNonSwiftModule(), expectedModule);
|
|
}
|
|
|
|
// If the reference goes from a distributed module to a local module,
|
|
// the compiler may have picked up an undesired module. We usually expect
|
|
// distributed modules to only reference other distributed modules.
|
|
// Local modules can reference both local modules and distributed modules.
|
|
if (referenceModuleIsDistributed) {
|
|
if (!expectedModule->isNonUserModule()) {
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_layering_expected_local,
|
|
referenceModuleDecl, expectedModule);
|
|
} else if (foundModule && !foundModule->isNonUserModule()) {
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_layering_found_local,
|
|
referenceModuleDecl, foundModule);
|
|
}
|
|
}
|
|
|
|
// If a type moved between MyModule and MyModule_Private, it can be caused
|
|
// by the use of `-Xcc -D` to change the API of the modules, leading to
|
|
// decls moving between both modules.
|
|
if (errorKind == Kind::DeclMoved ||
|
|
errorKind == Kind::DeclKindChanged) {
|
|
StringRef foundModuleName = foundModule->getName().str();
|
|
StringRef expectedModuleName = expectedModule->getName().str();
|
|
if (foundModuleName != expectedModuleName &&
|
|
(foundModuleName.starts_with(expectedModuleName) ||
|
|
expectedModuleName.starts_with(foundModuleName)) &&
|
|
(expectedUnderlying ||
|
|
expectedModule->findUnderlyingClangModule())) {
|
|
ctx.Diags.diagnose(loc,
|
|
diag::modularization_issue_related_modules,
|
|
declIsType, name);
|
|
}
|
|
}
|
|
|
|
ctx.Diags.flushConsumers();
|
|
}
|
|
|
|
void TypeError::diagnose(const ModuleFile *MF) const {
|
|
MF->getContext().Diags.diagnose(MF->getSourceLoc(),
|
|
diag::modularization_issue_side_effect_type_error,
|
|
name);
|
|
}
|
|
|
|
void ExtensionError::diagnose(const ModuleFile *MF) const {
|
|
MF->getContext().Diags.diagnose(MF->getSourceLoc(),
|
|
diag::modularization_issue_side_effect_extension_error);
|
|
}
|
|
|
|
llvm::Error
|
|
ModuleFile::diagnoseModularizationError(llvm::Error error,
|
|
DiagnosticBehavior limit) const {
|
|
auto handleModularizationError =
|
|
[&](const ModularizationError &modularError) -> llvm::Error {
|
|
modularError.diagnose(this, limit);
|
|
return llvm::Error::success();
|
|
};
|
|
llvm::Error outError = llvm::handleErrors(std::move(error),
|
|
handleModularizationError,
|
|
[&](TypeError &typeError) -> llvm::Error {
|
|
if (typeError.diagnoseUnderlyingReason(handleModularizationError)) {
|
|
typeError.diagnose(this);
|
|
return llvm::Error::success();
|
|
}
|
|
return llvm::make_error<TypeError>(std::move(typeError));
|
|
},
|
|
[&](ExtensionError &extError) -> llvm::Error {
|
|
if (extError.diagnoseUnderlyingReason(handleModularizationError)) {
|
|
extError.diagnose(this);
|
|
return llvm::Error::success();
|
|
}
|
|
return llvm::make_error<ExtensionError>(std::move(extError));
|
|
});
|
|
|
|
return outError;
|
|
}
|
|
|
|
void
|
|
ConformanceXRefError::diagnose(const ModuleFile *MF,
|
|
DiagnosticBehavior limit) const {
|
|
auto &diags = MF->getContext().Diags;
|
|
diags.diagnose(MF->getSourceLoc(),
|
|
diag::modularization_issue_conformance_xref_error,
|
|
name, protoName, expectedModule->getName())
|
|
.limitBehavior(limit);
|
|
}
|
|
|
|
llvm::Error ModuleFile::diagnoseFatal(llvm::Error error) const {
|
|
|
|
auto &ctx = getContext();
|
|
if (FileContext) {
|
|
if (ctx.LangOpts.EnableDeserializationRecovery) {
|
|
error = diagnoseModularizationError(std::move(error));
|
|
|
|
// If no error is left, it was reported as a diagnostic. There's no
|
|
// need to crash.
|
|
if (!error)
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
// General deserialization failure message.
|
|
ctx.Diags.diagnose(getSourceLoc(), diag::serialization_fatal, Core->Name);
|
|
}
|
|
// Unless in the debugger, crash. ModuleFileSharedCore::fatal() calls abort().
|
|
// This allows aggregation of crash logs for compiler development, but in a
|
|
// long-running process like LLDB this is undesirable. Only abort() if not in
|
|
// the debugger.
|
|
if (!ctx.LangOpts.DebuggerSupport)
|
|
Core->fatal(std::move(error));
|
|
|
|
// Otherwise, augment the error with contextual information at this point
|
|
// of failure and pass it back to be reported later.
|
|
std::string msg;
|
|
{
|
|
llvm::raw_string_ostream os(msg);
|
|
Core->outputDiagnosticInfo(os);
|
|
os << '\n';
|
|
llvm::sys::PrintStackTrace(os, 128);
|
|
}
|
|
msg += ": " + toString(std::move(error));
|
|
return llvm::make_error<FatalDeserializationError>(msg);
|
|
}
|
|
|
|
void ModuleFile::outputDiagnosticInfo(llvm::raw_ostream &os) const {
|
|
Core->outputDiagnosticInfo(os);
|
|
}
|
|
|
|
static std::optional<swift::AccessorKind> getActualAccessorKind(uint8_t raw) {
|
|
switch (serialization::AccessorKind(raw)) {
|
|
#define ACCESSOR(ID, KEYWORD) \
|
|
case serialization::AccessorKind::ID: \
|
|
return swift::AccessorKind::ID;
|
|
#include "swift/AST/AccessorKinds.def"
|
|
}
|
|
|
|
return std::nullopt;
|
|
}
|
|
|
|
/// Translate from the serialization DefaultArgumentKind enumerators, which are
|
|
/// guaranteed to be stable, to the AST ones.
|
|
static std::optional<swift::DefaultArgumentKind>
|
|
getActualDefaultArgKind(uint8_t raw) {
|
|
switch (static_cast<serialization::DefaultArgumentKind>(raw)) {
|
|
#define CASE(X) \
|
|
case serialization::DefaultArgumentKind::X: \
|
|
return swift::DefaultArgumentKind::X;
|
|
CASE(None)
|
|
CASE(Normal)
|
|
CASE(Inherited)
|
|
CASE(Column)
|
|
CASE(FileID)
|
|
CASE(FileIDSpelledAsFile)
|
|
CASE(FilePath)
|
|
CASE(FilePathSpelledAsFile)
|
|
CASE(Line)
|
|
CASE(Function)
|
|
CASE(DSOHandle)
|
|
CASE(NilLiteral)
|
|
CASE(EmptyArray)
|
|
CASE(EmptyDictionary)
|
|
CASE(StoredProperty)
|
|
CASE(ExpressionMacro)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static std::optional<swift::ActorIsolation::Kind>
|
|
getActualActorIsolationKind(uint8_t raw) {
|
|
switch (static_cast<serialization::ActorIsolation>(raw)) {
|
|
#define CASE(X) \
|
|
case serialization::ActorIsolation::X: \
|
|
return swift::ActorIsolation::Kind::X;
|
|
CASE(Unspecified)
|
|
CASE(ActorInstance)
|
|
CASE(Nonisolated)
|
|
CASE(CallerIsolationInheriting)
|
|
CASE(NonisolatedUnsafe)
|
|
CASE(GlobalActor)
|
|
CASE(Erased)
|
|
#undef CASE
|
|
case serialization::ActorIsolation::GlobalActorUnsafe:
|
|
return swift::ActorIsolation::GlobalActor;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static std::optional<StableSerializationPath::ExternalPath::ComponentKind>
|
|
getActualClangDeclPathComponentKind(uint64_t raw) {
|
|
switch (static_cast<serialization::ClangDeclPathComponentKind>(raw)) {
|
|
#define CASE(ID) \
|
|
case serialization::ClangDeclPathComponentKind::ID: \
|
|
return StableSerializationPath::ExternalPath::ID;
|
|
CASE(Record)
|
|
CASE(Enum)
|
|
CASE(Namespace)
|
|
CASE(Typedef)
|
|
CASE(TypedefAnonDecl)
|
|
CASE(ObjCInterface)
|
|
CASE(ObjCProtocol)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
Expected<ParameterList *> ModuleFile::readParameterList() {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 8> scratch;
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
unsigned recordID =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(entry.ID, scratch));
|
|
if (recordID != PARAMETERLIST)
|
|
fatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
|
|
ArrayRef<uint64_t> rawMemberIDs;
|
|
decls_block::ParameterListLayout::readRecord(scratch, rawMemberIDs);
|
|
|
|
SmallVector<ParamDecl *, 8> params;
|
|
for (DeclID paramID : rawMemberIDs) {
|
|
Decl *param;
|
|
SET_OR_RETURN_ERROR(param, getDeclChecked(paramID));
|
|
params.push_back(cast<ParamDecl>(param));
|
|
}
|
|
|
|
return ParameterList::create(getContext(), params);
|
|
}
|
|
|
|
static std::optional<swift::VarDecl::Introducer>
|
|
getActualVarDeclIntroducer(serialization::VarDeclIntroducer raw) {
|
|
switch (raw) {
|
|
#define CASE(ID) \
|
|
case serialization::VarDeclIntroducer::ID: \
|
|
return swift::VarDecl::Introducer::ID;
|
|
CASE(Let)
|
|
CASE(Var)
|
|
CASE(InOut)
|
|
CASE(Borrowing)
|
|
}
|
|
#undef CASE
|
|
return std::nullopt;
|
|
}
|
|
|
|
Expected<Pattern *> ModuleFile::readPattern(DeclContext *owningDC) {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 8> scratch;
|
|
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
llvm::BitstreamEntry next =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (next.Kind != llvm::BitstreamEntry::Record)
|
|
return diagnoseFatal();
|
|
|
|
/// Local function to record the type of this pattern.
|
|
auto recordPatternType = [&](Pattern *pattern, Type type) {
|
|
if (type->hasTypeParameter())
|
|
pattern->setDelayedInterfaceType(type, owningDC);
|
|
else
|
|
pattern->setType(type);
|
|
};
|
|
|
|
unsigned kind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(next.ID, scratch));
|
|
switch (kind) {
|
|
case decls_block::PAREN_PATTERN: {
|
|
Pattern *subPattern;
|
|
SET_OR_RETURN_ERROR(subPattern, readPattern(owningDC));
|
|
|
|
auto result = ParenPattern::createImplicit(getContext(), subPattern);
|
|
|
|
if (Type interfaceType = subPattern->getDelayedInterfaceType())
|
|
result->setDelayedInterfaceType(interfaceType, owningDC);
|
|
else
|
|
result->setType(subPattern->getType());
|
|
restoreOffset.reset();
|
|
return result;
|
|
}
|
|
case decls_block::TUPLE_PATTERN: {
|
|
TypeID tupleTypeID;
|
|
unsigned count;
|
|
|
|
TuplePatternLayout::readRecord(scratch, tupleTypeID, count);
|
|
|
|
SmallVector<TuplePatternElt, 8> elements;
|
|
for ( ; count > 0; --count) {
|
|
scratch.clear();
|
|
next = fatalIfUnexpected(DeclTypeCursor.advance());
|
|
assert(next.Kind == llvm::BitstreamEntry::Record);
|
|
|
|
kind = fatalIfUnexpected(DeclTypeCursor.readRecord(next.ID, scratch));
|
|
if (kind != decls_block::TUPLE_PATTERN_ELT)
|
|
fatal(llvm::make_error<InvalidRecordKindError>(kind));
|
|
|
|
// FIXME: Add something for this record or remove it.
|
|
IdentifierID labelID;
|
|
TuplePatternEltLayout::readRecord(scratch, labelID);
|
|
Identifier label = getIdentifier(labelID);
|
|
|
|
Pattern *subPattern;
|
|
SET_OR_RETURN_ERROR(subPattern, readPattern(owningDC));
|
|
elements.push_back(TuplePatternElt(label, SourceLoc(), subPattern));
|
|
}
|
|
|
|
auto result = TuplePattern::createImplicit(getContext(), elements);
|
|
Type tupleType;
|
|
SET_OR_RETURN_ERROR(tupleType, getTypeChecked(tupleTypeID));
|
|
recordPatternType(result, tupleType);
|
|
restoreOffset.reset();
|
|
return result;
|
|
}
|
|
case decls_block::NAMED_PATTERN: {
|
|
DeclID varID;
|
|
TypeID typeID;
|
|
NamedPatternLayout::readRecord(scratch, varID, typeID);
|
|
|
|
auto deserialized = getDeclChecked(varID);
|
|
if (!deserialized) {
|
|
// Pass through the error. It's too bad that it affects the whole pattern,
|
|
// but that's what we get.
|
|
return deserialized.takeError();
|
|
}
|
|
|
|
auto var = cast<VarDecl>(deserialized.get());
|
|
auto result = NamedPattern::createImplicit(getContext(), var);
|
|
auto typeOrErr = getTypeChecked(typeID);
|
|
if (!typeOrErr)
|
|
return typeOrErr.takeError();
|
|
recordPatternType(result, typeOrErr.get());
|
|
restoreOffset.reset();
|
|
return result;
|
|
}
|
|
case decls_block::ANY_PATTERN: {
|
|
TypeID typeID;
|
|
bool isAsyncLet;
|
|
|
|
AnyPatternLayout::readRecord(scratch, typeID, isAsyncLet);
|
|
auto result = AnyPattern::createImplicit(getContext());
|
|
if (isAsyncLet) {
|
|
result->setIsAsyncLet();
|
|
}
|
|
recordPatternType(result, getType(typeID));
|
|
restoreOffset.reset();
|
|
return result;
|
|
}
|
|
case decls_block::TYPED_PATTERN: {
|
|
TypeID typeID;
|
|
TypedPatternLayout::readRecord(scratch, typeID);
|
|
|
|
Expected<Pattern *> subPattern = readPattern(owningDC);
|
|
if (!subPattern) {
|
|
// Pass through any errors.
|
|
return subPattern;
|
|
}
|
|
|
|
auto type = getType(typeID);
|
|
auto result = TypedPattern::createImplicit(getContext(),
|
|
subPattern.get(), type);
|
|
recordPatternType(result, type);
|
|
restoreOffset.reset();
|
|
return result;
|
|
}
|
|
case decls_block::VAR_PATTERN: {
|
|
unsigned rawIntroducer;
|
|
BindingPatternLayout::readRecord(scratch, rawIntroducer);
|
|
|
|
Pattern *subPattern;
|
|
SET_OR_RETURN_ERROR(subPattern, readPattern(owningDC));
|
|
|
|
auto introducer = getActualVarDeclIntroducer(
|
|
(serialization::VarDeclIntroducer) rawIntroducer);
|
|
if (!introducer)
|
|
return diagnoseFatal();
|
|
|
|
auto result = BindingPattern::createImplicit(
|
|
getContext(), *introducer, subPattern);
|
|
if (Type interfaceType = subPattern->getDelayedInterfaceType())
|
|
result->setDelayedInterfaceType(interfaceType, owningDC);
|
|
else
|
|
result->setType(subPattern->getType());
|
|
restoreOffset.reset();
|
|
return result;
|
|
}
|
|
|
|
default:
|
|
return llvm::make_error<InvalidRecordKindError>(kind);
|
|
}
|
|
}
|
|
|
|
SILLayout *ModuleFile::readSILLayout(llvm::BitstreamCursor &Cursor) {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 16> scratch;
|
|
|
|
llvm::BitstreamEntry next =
|
|
fatalIfUnexpected(Cursor.advance(AF_DontPopBlockAtEnd));
|
|
assert(next.Kind == llvm::BitstreamEntry::Record);
|
|
|
|
unsigned kind = fatalIfUnexpected(Cursor.readRecord(next.ID, scratch));
|
|
switch (kind) {
|
|
case decls_block::SIL_LAYOUT: {
|
|
GenericSignatureID rawGenericSig;
|
|
bool capturesGenerics;
|
|
unsigned numFields;
|
|
ArrayRef<uint64_t> types;
|
|
decls_block::SILLayoutLayout::readRecord(scratch, rawGenericSig,
|
|
capturesGenerics,
|
|
numFields, types);
|
|
|
|
SmallVector<SILField, 4> fields;
|
|
for (auto fieldInfo : types.slice(0, numFields)) {
|
|
bool isMutable = fieldInfo & 0x80000000U;
|
|
auto typeId = fieldInfo & 0x7FFFFFFFU;
|
|
fields.push_back(
|
|
SILField(getType(typeId)->getCanonicalType(),
|
|
isMutable));
|
|
}
|
|
|
|
CanGenericSignature canSig;
|
|
if (auto sig = getGenericSignature(rawGenericSig))
|
|
canSig = sig.getCanonicalSignature();
|
|
return SILLayout::get(getContext(), canSig, fields, capturesGenerics);
|
|
}
|
|
default:
|
|
fatal(llvm::make_error<InvalidRecordKindError>(kind));
|
|
}
|
|
}
|
|
|
|
namespace swift {
|
|
class ProtocolConformanceDeserializer {
|
|
ModuleFile &MF;
|
|
ASTContext &ctx;
|
|
|
|
using TypeID = serialization::TypeID;
|
|
using ProtocolConformanceID = serialization::ProtocolConformanceID;
|
|
public:
|
|
ProtocolConformanceDeserializer(ModuleFile &mf)
|
|
: MF(mf), ctx(mf.getContext()) {}
|
|
|
|
Expected<ProtocolConformance *>
|
|
read(ModuleFile::Serialized<ProtocolConformance *> &entry);
|
|
|
|
Expected<ProtocolConformance *>
|
|
readSelfProtocolConformance(ArrayRef<uint64_t> data);
|
|
Expected<ProtocolConformance *>
|
|
readSpecializedProtocolConformance(ArrayRef<uint64_t> data);
|
|
Expected<ProtocolConformance *>
|
|
readInheritedProtocolConformance(ArrayRef<uint64_t> data);
|
|
Expected<ProtocolConformance *>
|
|
readBuiltinProtocolConformance(ArrayRef<uint64_t> data);
|
|
Expected<ProtocolConformance *>
|
|
readNormalProtocolConformance(ArrayRef<uint64_t> data,
|
|
ModuleFile::Serialized<ProtocolConformance *> &entry);
|
|
Expected<ProtocolConformance *>
|
|
readNormalProtocolConformanceXRef(ArrayRef<uint64_t> data);
|
|
|
|
Expected<PackConformance *>
|
|
read(ModuleFile::Serialized<PackConformance *> &entry);
|
|
|
|
Expected<AbstractConformance *>
|
|
read(ModuleFile::Serialized<AbstractConformance *> &entry);
|
|
};
|
|
} // end namespace swift
|
|
|
|
Expected<ProtocolConformance*>
|
|
ProtocolConformanceDeserializer::read(
|
|
ModuleFile::Serialized<ProtocolConformance *> &conformanceEntry) {
|
|
SmallVector<uint64_t, 16> scratch;
|
|
|
|
if (auto s = ctx.Stats)
|
|
++s->getFrontendCounters().NumConformancesDeserialized;
|
|
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance());
|
|
|
|
if (entry.Kind != llvm::BitstreamEntry::Record) {
|
|
// We don't know how to serialize types represented by sub-blocks.
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
StringRef blobData;
|
|
unsigned kind = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
assert(blobData.empty());
|
|
|
|
switch (kind) {
|
|
case decls_block::SELF_PROTOCOL_CONFORMANCE:
|
|
return readSelfProtocolConformance(scratch);
|
|
case decls_block::SPECIALIZED_PROTOCOL_CONFORMANCE:
|
|
return readSpecializedProtocolConformance(scratch);
|
|
case decls_block::INHERITED_PROTOCOL_CONFORMANCE:
|
|
return readInheritedProtocolConformance(scratch);
|
|
case decls_block::BUILTIN_PROTOCOL_CONFORMANCE:
|
|
return readBuiltinProtocolConformance(scratch);
|
|
case decls_block::NORMAL_PROTOCOL_CONFORMANCE:
|
|
return readNormalProtocolConformance(scratch, conformanceEntry);
|
|
case decls_block::PROTOCOL_CONFORMANCE_XREF:
|
|
return readNormalProtocolConformanceXRef(scratch);
|
|
|
|
// Not a protocol conformance.
|
|
default:
|
|
return MF.diagnoseFatal(llvm::make_error<InvalidRecordKindError>(kind));
|
|
}
|
|
}
|
|
|
|
Expected<ProtocolConformance *>
|
|
ProtocolConformanceDeserializer::readSelfProtocolConformance(
|
|
ArrayRef<uint64_t> scratch) {
|
|
using namespace decls_block;
|
|
|
|
DeclID protoID;
|
|
SelfProtocolConformanceLayout::readRecord(scratch, protoID);
|
|
|
|
auto decl = MF.getDeclChecked(protoID);
|
|
if (!decl)
|
|
return decl.takeError();
|
|
|
|
auto proto = cast<ProtocolDecl>(decl.get());
|
|
auto conformance = ctx.getSelfConformance(proto);
|
|
return conformance;
|
|
}
|
|
|
|
Expected<ProtocolConformance *>
|
|
ProtocolConformanceDeserializer::readSpecializedProtocolConformance(
|
|
ArrayRef<uint64_t> scratch) {
|
|
using namespace decls_block;
|
|
|
|
ProtocolConformanceID conformanceID;
|
|
TypeID conformingTypeID;
|
|
SubstitutionMapID substitutionMapID;
|
|
SpecializedProtocolConformanceLayout::readRecord(scratch,
|
|
conformanceID,
|
|
conformingTypeID,
|
|
substitutionMapID);
|
|
|
|
Type conformingType = MF.getType(conformingTypeID);
|
|
|
|
PrettyStackTraceType trace(MF.getAssociatedModule()->getASTContext(),
|
|
"reading specialized conformance for",
|
|
conformingType);
|
|
|
|
auto subMapOrError = MF.getSubstitutionMapChecked(substitutionMapID);
|
|
if (!subMapOrError)
|
|
return subMapOrError.takeError();
|
|
auto subMap = subMapOrError.get();
|
|
|
|
ProtocolConformanceRef genericConformance;
|
|
SET_OR_RETURN_ERROR(genericConformance,
|
|
MF.getConformanceChecked(conformanceID));
|
|
|
|
PrettyStackTraceDecl traceTo("... to", genericConformance.getProtocol());
|
|
++NumNormalProtocolConformancesLoaded;
|
|
|
|
auto *rootConformance = cast<NormalProtocolConformance>(
|
|
genericConformance.getConcrete());
|
|
|
|
auto conformance =
|
|
ctx.getSpecializedConformance(conformingType, rootConformance, subMap);
|
|
return conformance;
|
|
}
|
|
|
|
Expected<ProtocolConformance *>
|
|
ProtocolConformanceDeserializer::readInheritedProtocolConformance(
|
|
ArrayRef<uint64_t> scratch) {
|
|
using namespace decls_block;
|
|
|
|
ProtocolConformanceID conformanceID;
|
|
TypeID conformingTypeID;
|
|
InheritedProtocolConformanceLayout::readRecord(scratch, conformanceID,
|
|
conformingTypeID);
|
|
|
|
auto conformingTypeOrError =
|
|
MF.getTypeChecked(conformingTypeID);
|
|
if (!conformingTypeOrError)
|
|
return conformingTypeOrError.takeError();
|
|
Type conformingType = conformingTypeOrError.get();
|
|
|
|
PrettyStackTraceType trace(ctx, "reading inherited conformance for",
|
|
conformingType);
|
|
|
|
ProtocolConformanceRef inheritedConformance;
|
|
SET_OR_RETURN_ERROR(inheritedConformance,
|
|
MF.getConformanceChecked(conformanceID));
|
|
PrettyStackTraceDecl traceTo("... to",
|
|
inheritedConformance.getProtocol());
|
|
|
|
assert(inheritedConformance.isConcrete() &&
|
|
"Abstract inherited conformance?");
|
|
auto conformance =
|
|
ctx.getInheritedConformance(conformingType,
|
|
inheritedConformance.getConcrete());
|
|
return conformance;
|
|
}
|
|
|
|
Expected<ProtocolConformance *>
|
|
ProtocolConformanceDeserializer::readBuiltinProtocolConformance(
|
|
ArrayRef<uint64_t> scratch) {
|
|
using namespace decls_block;
|
|
|
|
TypeID conformingTypeID;
|
|
DeclID protoID;
|
|
unsigned builtinConformanceKind;
|
|
BuiltinProtocolConformanceLayout::readRecord(scratch, conformingTypeID,
|
|
protoID, builtinConformanceKind);
|
|
|
|
auto conformingType = MF.getTypeChecked(conformingTypeID);
|
|
if (!conformingType)
|
|
return conformingType.takeError();
|
|
|
|
auto decl = MF.getDeclChecked(protoID);
|
|
if (!decl)
|
|
return decl.takeError();
|
|
|
|
auto proto = cast<ProtocolDecl>(decl.get());
|
|
|
|
auto conformance = ctx.getBuiltinConformance(
|
|
conformingType.get(), proto,
|
|
static_cast<BuiltinConformanceKind>(builtinConformanceKind));
|
|
return conformance;
|
|
}
|
|
|
|
Expected<ProtocolConformance *>
|
|
ProtocolConformanceDeserializer::readNormalProtocolConformanceXRef(
|
|
ArrayRef<uint64_t> scratch) {
|
|
using namespace decls_block;
|
|
|
|
DeclID protoID;
|
|
DeclID nominalID;
|
|
ModuleID moduleID;
|
|
ProtocolConformanceXrefLayout::readRecord(scratch, protoID, nominalID,
|
|
moduleID);
|
|
|
|
Decl *maybeNominal;
|
|
SET_OR_RETURN_ERROR(maybeNominal, MF.getDeclChecked(nominalID));
|
|
auto nominal = cast<NominalTypeDecl>(maybeNominal);
|
|
PrettyStackTraceDecl trace("cross-referencing conformance for", nominal);
|
|
|
|
Decl *maybeProto;
|
|
SET_OR_RETURN_ERROR(maybeProto, MF.getDeclChecked(protoID));
|
|
auto proto = cast<ProtocolDecl>(maybeProto);
|
|
PrettyStackTraceDecl traceTo("... to", proto);
|
|
|
|
auto module = MF.getModule(moduleID);
|
|
|
|
// FIXME: If the module hasn't been loaded, we probably don't want to fall
|
|
// back to the current module like this.
|
|
if (!module)
|
|
module = MF.getAssociatedModule();
|
|
|
|
PrettyStackTraceModuleFile traceMsg(
|
|
"If you're seeing a crash here, check that your SDK and dependencies "
|
|
"are at least as new as the versions used to build", MF);
|
|
|
|
// Because Sendable conformances are currently inferred with
|
|
// 'ImplicitKnownProtocolConformanceRequest' in swift::lookupConformance,
|
|
// we may end up in a situation where we are deserializing such inferred
|
|
// conformance but a lookup on the 'NominalDecl' will not succeed nor
|
|
// will it run inference logic. For now, special-case 'Sendable' lookups
|
|
// here.
|
|
// TODO: Sink Sendable derivation into the conformance lookup table
|
|
if (proto->isSpecificProtocol(KnownProtocolKind::Sendable)) {
|
|
auto conformanceRef = lookupConformance(nominal->getDeclaredInterfaceType(), proto);
|
|
if (conformanceRef.isConcrete())
|
|
return conformanceRef.getConcrete();
|
|
} else {
|
|
SmallVector<ProtocolConformance *, 2> conformances;
|
|
nominal->lookupConformance(proto, conformances);
|
|
if (!conformances.empty())
|
|
return conformances.front();
|
|
}
|
|
|
|
auto error = llvm::make_error<ConformanceXRefError>(
|
|
nominal->getName(), proto->getName(), module);
|
|
|
|
// Diagnose the root error here.
|
|
error = llvm::handleErrors(std::move(error),
|
|
[&](const ConformanceXRefError &error) -> llvm::Error {
|
|
error.diagnose(&MF);
|
|
return llvm::make_error<ConformanceXRefError>(std::move(error));
|
|
});
|
|
|
|
return error;
|
|
}
|
|
|
|
Expected<ProtocolConformance *>
|
|
ProtocolConformanceDeserializer::readNormalProtocolConformance(
|
|
ArrayRef<uint64_t> scratch,
|
|
ModuleFile::Serialized<ProtocolConformance *> &conformanceEntry) {
|
|
using namespace decls_block;
|
|
|
|
DeclID protoID;
|
|
DeclContextID contextID;
|
|
unsigned valueCount, typeCount, conformanceCount;
|
|
unsigned rawOptions;
|
|
TypeID globalActorTypeID;
|
|
ArrayRef<uint64_t> rawIDs;
|
|
|
|
NormalProtocolConformanceLayout::readRecord(scratch, protoID,
|
|
contextID, typeCount,
|
|
valueCount, conformanceCount,
|
|
rawOptions,
|
|
globalActorTypeID,
|
|
rawIDs);
|
|
|
|
auto doOrError = MF.getDeclContextChecked(contextID);
|
|
if (!doOrError)
|
|
return doOrError.takeError();
|
|
DeclContext *dc = doOrError.get();
|
|
|
|
assert(!isa<ClangModuleUnit>(dc->getModuleScopeContext())
|
|
&& "should not have serialized a conformance from a clang module");
|
|
Type conformingType = dc->getSelfInterfaceType();
|
|
PrettyStackTraceType trace(ctx, "reading conformance for", conformingType);
|
|
|
|
auto protoOrError = MF.getDeclChecked(protoID);
|
|
if (!protoOrError)
|
|
return protoOrError.takeError();
|
|
auto proto = cast<ProtocolDecl>(protoOrError.get());
|
|
|
|
PrettyStackTraceDecl traceTo("... to", proto);
|
|
|
|
auto globalActorTypeOrError = MF.getTypeChecked(globalActorTypeID);
|
|
if (!globalActorTypeOrError)
|
|
return globalActorTypeOrError.takeError();
|
|
auto globalActorType = globalActorTypeOrError.get();
|
|
|
|
TypeExpr *globalActorTypeExpr = nullptr;
|
|
if (globalActorType) {
|
|
globalActorTypeExpr = TypeExpr::createImplicit(globalActorType, ctx);
|
|
rawOptions |=
|
|
static_cast<unsigned>(ProtocolConformanceFlags::GlobalActorIsolated);
|
|
}
|
|
|
|
auto conformance = ctx.getNormalConformance(
|
|
conformingType, proto, SourceLoc(), /*inheritedTypeRepr=*/nullptr, dc,
|
|
ProtocolConformanceState::Incomplete,
|
|
ProtocolConformanceOptions(rawOptions, globalActorTypeExpr));
|
|
|
|
if (conformance->isConformanceOfProtocol()) {
|
|
auto &C = dc->getASTContext();
|
|
|
|
// Currently this should only be happening for the
|
|
// "DistributedActor as Actor" SILGen generated conformance.
|
|
// See `isConformanceOfProtocol` for details, if adding more such
|
|
// conformances, consider changing the way we structure their construction.
|
|
assert(conformance->getProtocol()->getInterfaceType()->isEqual(
|
|
C.getProtocol(KnownProtocolKind::Actor)->getInterfaceType()) &&
|
|
"Only expected to 'skip' finishNormalConformance for manually "
|
|
"created DistributedActor-as-Actor conformance.");
|
|
|
|
// Swap the conformance for the special conjured up one.
|
|
// We do NOT 'registerProtocolConformance' it because it is a
|
|
// protocol-to-protocol conformance, and we cannot register those since
|
|
// protocols do not have a conformance table which registration requires.
|
|
conformance = getDistributedActorAsActorConformance(C);
|
|
conformanceEntry = conformance; // record it
|
|
|
|
return conformance;
|
|
}
|
|
|
|
// Record this conformance.
|
|
if (conformanceEntry.isComplete()) {
|
|
assert(conformanceEntry.get() == conformance);
|
|
return conformance;
|
|
}
|
|
|
|
uint64_t offset = conformanceEntry;
|
|
conformanceEntry = conformance;
|
|
|
|
if (!dc->getSelfProtocolDecl())
|
|
dc->getSelfNominalTypeDecl()->registerProtocolConformance(conformance);
|
|
|
|
// If the conformance is complete, we're done.
|
|
if (conformance->isComplete())
|
|
return conformance;
|
|
|
|
conformance->setState(ProtocolConformanceState::Complete);
|
|
|
|
conformance->setLazyLoader(&MF, offset);
|
|
return conformance;
|
|
}
|
|
|
|
Expected<AbstractConformance *>
|
|
ProtocolConformanceDeserializer::read(
|
|
ModuleFile::Serialized<AbstractConformance *> &conformanceEntry) {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 16> scratch;
|
|
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance());
|
|
|
|
if (entry.Kind != llvm::BitstreamEntry::Record) {
|
|
// We don't know how to serialize types represented by sub-blocks.
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
StringRef blobData;
|
|
unsigned kind = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
assert(blobData.empty());
|
|
|
|
if (kind != decls_block::ABSTRACT_CONFORMANCE)
|
|
return MF.diagnoseFatal(llvm::make_error<InvalidRecordKindError>(kind));
|
|
|
|
TypeID conformingTypeID;
|
|
DeclID protocolID;
|
|
AbstractConformanceLayout::readRecord(scratch, conformingTypeID, protocolID);
|
|
|
|
auto conformingTypeOrError = MF.getTypeChecked(conformingTypeID);
|
|
if (!conformingTypeOrError)
|
|
return conformingTypeOrError.takeError();
|
|
auto conformingType = conformingTypeOrError.get();
|
|
|
|
auto protocolOrError = MF.getDeclChecked(protocolID);
|
|
if (!protocolOrError)
|
|
return protocolOrError.takeError();
|
|
auto *protocol = cast<ProtocolDecl>(protocolOrError.get());
|
|
|
|
return ProtocolConformanceRef::forAbstract(conformingType, protocol)
|
|
.getAbstract();
|
|
}
|
|
|
|
Expected<PackConformance*>
|
|
ProtocolConformanceDeserializer::read(
|
|
ModuleFile::Serialized<PackConformance *> &conformanceEntry) {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 16> scratch;
|
|
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance());
|
|
|
|
if (entry.Kind != llvm::BitstreamEntry::Record) {
|
|
// We don't know how to serialize types represented by sub-blocks.
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
StringRef blobData;
|
|
unsigned kind = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
assert(blobData.empty());
|
|
|
|
if (kind != decls_block::PACK_CONFORMANCE)
|
|
return MF.diagnoseFatal(llvm::make_error<InvalidRecordKindError>(kind));
|
|
|
|
TypeID patternTypeID;
|
|
DeclID protocolID;
|
|
ArrayRef<uint64_t> patternConformanceIDs;
|
|
PackConformanceLayout::readRecord(scratch,
|
|
patternTypeID, protocolID,
|
|
patternConformanceIDs);
|
|
|
|
auto patternTypeOrError = MF.getTypeChecked(patternTypeID);
|
|
if (!patternTypeOrError)
|
|
return patternTypeOrError.takeError();
|
|
auto patternType = patternTypeOrError.get();
|
|
|
|
auto protocolOrError = MF.getDeclChecked(protocolID);
|
|
if (!protocolOrError)
|
|
return protocolOrError.takeError();
|
|
auto *protocol = protocolOrError.get();
|
|
|
|
PrettyStackTraceType trace(MF.getAssociatedModule()->getASTContext(),
|
|
"reading pack conformance for",
|
|
patternType);
|
|
|
|
SmallVector<ProtocolConformanceRef, 4> patternConformances;
|
|
for (auto confID : patternConformanceIDs) {
|
|
auto confOrError = MF.getConformanceChecked(confID);
|
|
if (!confOrError)
|
|
return confOrError.takeError();
|
|
patternConformances.push_back(confOrError.get());
|
|
}
|
|
|
|
auto conformance =
|
|
PackConformance::get(patternType->castTo<PackType>(),
|
|
cast<ProtocolDecl>(protocol),
|
|
patternConformances);
|
|
return conformance;
|
|
}
|
|
|
|
ProtocolConformanceRef
|
|
ModuleFile::getConformance(ProtocolConformanceID id) {
|
|
auto conformance = getConformanceChecked(id);
|
|
if (!conformance)
|
|
fatal(conformance.takeError());
|
|
return conformance.get();
|
|
}
|
|
|
|
Expected<ProtocolConformanceRef>
|
|
ModuleFile::getConformanceChecked(ProtocolConformanceID conformanceID) {
|
|
using namespace decls_block;
|
|
|
|
if (conformanceID == 0) return ProtocolConformanceRef::forInvalid();
|
|
|
|
switch (conformanceID & SerializedProtocolConformanceKind::Mask) {
|
|
case SerializedProtocolConformanceKind::Abstract: {
|
|
auto conformanceIndex = (conformanceID >> SerializedProtocolConformanceKind::Shift) - 1;
|
|
assert(conformanceIndex < AbstractConformances.size() &&
|
|
"invalid abstract conformance ID");
|
|
auto &conformanceOrOffset = AbstractConformances[conformanceIndex];
|
|
if (!conformanceOrOffset.isComplete()) {
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error = diagnoseFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(conformanceOrOffset)))
|
|
return std::move(error);
|
|
|
|
auto result =
|
|
ProtocolConformanceDeserializer(*this).read(conformanceOrOffset);
|
|
if (!result)
|
|
return result.takeError();
|
|
|
|
conformanceOrOffset = result.get();
|
|
}
|
|
auto conformance = conformanceOrOffset.get();
|
|
return ProtocolConformanceRef(conformance);
|
|
}
|
|
|
|
case SerializedProtocolConformanceKind::Concrete: {
|
|
auto conformanceIndex = (conformanceID >> SerializedProtocolConformanceKind::Shift) - 1;
|
|
assert(conformanceIndex < Conformances.size() && "invalid conformance ID");
|
|
auto &conformanceOrOffset = Conformances[conformanceIndex];
|
|
if (!conformanceOrOffset.isComplete()) {
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error = diagnoseFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(conformanceOrOffset)))
|
|
return std::move(error);
|
|
|
|
auto result =
|
|
ProtocolConformanceDeserializer(*this).read(conformanceOrOffset);
|
|
if (!result)
|
|
return result.takeError();
|
|
|
|
conformanceOrOffset = result.get();
|
|
}
|
|
auto conformance = conformanceOrOffset.get();
|
|
return ProtocolConformanceRef(conformance);
|
|
}
|
|
|
|
case SerializedProtocolConformanceKind::Pack: {
|
|
auto conformanceIndex = (conformanceID >> SerializedProtocolConformanceKind::Shift) - 1;
|
|
assert(conformanceIndex < PackConformances.size() && "invalid pack conformance ID");
|
|
auto &conformanceOrOffset = PackConformances[conformanceIndex];
|
|
if (!conformanceOrOffset.isComplete()) {
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error = diagnoseFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(conformanceOrOffset)))
|
|
return std::move(error);
|
|
|
|
auto result =
|
|
ProtocolConformanceDeserializer(*this).read(conformanceOrOffset);
|
|
if (!result)
|
|
return result.takeError();
|
|
|
|
conformanceOrOffset = result.get();
|
|
}
|
|
auto conformance = conformanceOrOffset.get();
|
|
return ProtocolConformanceRef(conformance);
|
|
}
|
|
|
|
default:
|
|
llvm_unreachable("Invalid conformance");
|
|
}
|
|
}
|
|
|
|
Expected<GenericParamList *>
|
|
ModuleFile::maybeReadGenericParams(DeclContext *DC) {
|
|
using namespace decls_block;
|
|
|
|
assert(DC && "need a context for the decls in the list");
|
|
|
|
BCOffsetRAII lastRecordOffset(DeclTypeCursor);
|
|
SmallVector<uint64_t, 8> scratch;
|
|
StringRef blobData;
|
|
|
|
llvm::BitstreamEntry next =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (next.Kind != llvm::BitstreamEntry::Record)
|
|
return nullptr;
|
|
|
|
unsigned kind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(next.ID, scratch, &blobData));
|
|
if (kind != GENERIC_PARAM_LIST)
|
|
return nullptr;
|
|
lastRecordOffset.reset();
|
|
|
|
SmallVector<GenericTypeParamDecl *, 8> params;
|
|
|
|
ArrayRef<uint64_t> paramIDs;
|
|
GenericParamListLayout::readRecord(scratch, paramIDs);
|
|
for (DeclID nextParamID : paramIDs) {
|
|
Decl *nextParam;
|
|
SET_OR_RETURN_ERROR(nextParam, getDeclChecked(nextParamID));
|
|
|
|
auto genericParam = cast<GenericTypeParamDecl>(nextParam);
|
|
params.push_back(genericParam);
|
|
}
|
|
|
|
// Don't create empty generic parameter lists. (This should never happen in
|
|
// practice, but it doesn't hurt to be defensive.)
|
|
if (params.empty())
|
|
return nullptr;
|
|
|
|
return GenericParamList::create(getContext(), SourceLoc(),
|
|
params, SourceLoc(), { },
|
|
SourceLoc());
|
|
}
|
|
|
|
/// Translate from the requirement kind to the Serialization enum
|
|
/// values, which are guaranteed to be stable.
|
|
static std::optional<RequirementKind>
|
|
getActualRequirementKind(uint64_t rawKind) {
|
|
#define CASE(KIND) \
|
|
case serialization::GenericRequirementKind::KIND: \
|
|
return RequirementKind::KIND;
|
|
|
|
switch (rawKind) {
|
|
CASE(SameShape)
|
|
CASE(Conformance)
|
|
CASE(Superclass)
|
|
CASE(SameType)
|
|
CASE(Layout)
|
|
}
|
|
#undef CASE
|
|
|
|
return std::nullopt;
|
|
}
|
|
|
|
/// Translate from the requirement kind to the Serialization enum
|
|
/// values, which are guaranteed to be stable.
|
|
static std::optional<LayoutConstraintKind>
|
|
getActualLayoutConstraintKind(uint64_t rawKind) {
|
|
#define CASE(KIND) \
|
|
case LayoutRequirementKind::KIND: \
|
|
return LayoutConstraintKind::KIND;
|
|
|
|
switch (rawKind) {
|
|
CASE(NativeRefCountedObject)
|
|
CASE(RefCountedObject)
|
|
CASE(Trivial)
|
|
CASE(TrivialOfExactSize)
|
|
CASE(TrivialOfAtMostSize)
|
|
CASE(Class)
|
|
CASE(NativeClass)
|
|
CASE(UnknownLayout)
|
|
CASE(BridgeObject)
|
|
CASE(TrivialStride)
|
|
}
|
|
#undef CASE
|
|
|
|
return std::nullopt;
|
|
}
|
|
|
|
/// Translate from the param kind to the Serialization enum values, which are
|
|
/// guaranteed to be stable.
|
|
static std::optional<GenericTypeParamKind>
|
|
getActualParamKind(uint64_t rawKind) {
|
|
#define CASE(KIND) \
|
|
case serialization::GenericParamKind::KIND: \
|
|
return GenericTypeParamKind::KIND;
|
|
|
|
switch ((serialization::GenericParamKind)rawKind) {
|
|
CASE(Type)
|
|
CASE(Pack)
|
|
CASE(Value)
|
|
}
|
|
#undef CASE
|
|
|
|
return std::nullopt;
|
|
}
|
|
|
|
void ModuleFile::deserializeGenericRequirements(
|
|
ArrayRef<uint64_t> scratch,
|
|
unsigned &nextIndex,
|
|
SmallVectorImpl<Requirement> &requirements) {
|
|
auto error = deserializeGenericRequirementsChecked(scratch, nextIndex,
|
|
requirements);
|
|
if (error)
|
|
fatal(std::move(error));
|
|
}
|
|
|
|
llvm::Error ModuleFile::deserializeGenericRequirementsChecked(
|
|
ArrayRef<uint64_t> scratch,
|
|
unsigned &nextIndex,
|
|
SmallVectorImpl<Requirement> &requirements) {
|
|
using namespace decls_block;
|
|
|
|
auto numRequirements = scratch[nextIndex++];
|
|
requirements.reserve(numRequirements);
|
|
|
|
for (unsigned i = 0; i != numRequirements; ++i) {
|
|
auto maybeReqKind = getActualRequirementKind(scratch[nextIndex++]);
|
|
if (!maybeReqKind)
|
|
return diagnoseFatal();
|
|
auto reqKind = *maybeReqKind;
|
|
|
|
// General case
|
|
if (reqKind != RequirementKind::Layout) {
|
|
auto firstType = getTypeChecked(scratch[nextIndex++]);
|
|
if (!firstType) return firstType.takeError();
|
|
|
|
auto secondType = getTypeChecked(scratch[nextIndex++]);
|
|
if (!secondType) return secondType.takeError();
|
|
|
|
requirements.push_back(
|
|
Requirement(reqKind, firstType.get(), secondType.get()));
|
|
|
|
// Layout constraints
|
|
} else {
|
|
auto maybeKind =
|
|
getActualLayoutConstraintKind(scratch[nextIndex++]);
|
|
if (!maybeKind)
|
|
return diagnoseFatal();
|
|
auto kind = *maybeKind;
|
|
|
|
auto type = getTypeChecked(scratch[nextIndex++]);
|
|
if (!type) return type.takeError();
|
|
|
|
uint32_t size = scratch[nextIndex++];
|
|
uint32_t alignment = scratch[nextIndex++];
|
|
|
|
ASTContext &ctx = getContext();
|
|
LayoutConstraint layout;
|
|
if (kind != LayoutConstraintKind::TrivialOfAtMostSize &&
|
|
kind != LayoutConstraintKind::TrivialOfExactSize &&
|
|
kind != LayoutConstraintKind::TrivialStride)
|
|
layout = LayoutConstraint::getLayoutConstraint(kind, ctx);
|
|
else
|
|
layout =
|
|
LayoutConstraint::getLayoutConstraint(kind, size, alignment, ctx);
|
|
|
|
requirements.push_back(Requirement(reqKind, type.get(), layout));
|
|
}
|
|
}
|
|
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
void ModuleFile::readRequirementSignature(
|
|
SmallVectorImpl<Requirement> &requirements,
|
|
SmallVectorImpl<ProtocolTypeAlias> &typeAliases,
|
|
llvm::BitstreamCursor &Cursor) {
|
|
using namespace decls_block;
|
|
|
|
// Tentatively advance from this point to see if there's a
|
|
// REQUIREMENT_SIGNATURE record.
|
|
BCOffsetRAII lastRecordOffset(Cursor);
|
|
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(Cursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return;
|
|
|
|
SmallVector<uint64_t, 8> scratch;
|
|
StringRef blobData;
|
|
unsigned recordID = fatalIfUnexpected(
|
|
Cursor.readRecord(entry.ID, scratch, &blobData));
|
|
|
|
// This record is not part of the protocol requirement signature.
|
|
if (recordID != REQUIREMENT_SIGNATURE)
|
|
return;
|
|
|
|
// Accept the tentative advance.
|
|
lastRecordOffset.reset();
|
|
|
|
unsigned nextIndex = 0;
|
|
ArrayRef<uint64_t> rawData;
|
|
RequirementSignatureLayout::readRecord(scratch, rawData);
|
|
|
|
deserializeGenericRequirements(rawData, nextIndex, requirements);
|
|
rawData = rawData.slice(nextIndex);
|
|
|
|
if (rawData.size() % 2 != 0)
|
|
return diagnoseAndConsumeFatal();
|
|
|
|
while (!rawData.empty()) {
|
|
auto name = getIdentifier(rawData[0]);
|
|
auto underlyingType = getType(rawData[1]);
|
|
typeAliases.emplace_back(name, underlyingType);
|
|
|
|
rawData = rawData.slice(2);
|
|
}
|
|
}
|
|
|
|
void ModuleFile::readAssociatedTypes(
|
|
SmallVectorImpl<AssociatedTypeDecl *> &assocTypes,
|
|
llvm::BitstreamCursor &Cursor) {
|
|
using namespace decls_block;
|
|
|
|
BCOffsetRAII lastRecordOffset(Cursor);
|
|
SmallVector<uint64_t, 8> scratch;
|
|
StringRef blobData;
|
|
|
|
while (true) {
|
|
lastRecordOffset.reset();
|
|
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(Cursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
break;
|
|
|
|
scratch.clear();
|
|
unsigned recordID = fatalIfUnexpected(
|
|
Cursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != ASSOCIATED_TYPE)
|
|
break;
|
|
|
|
DeclID declID;
|
|
AssociatedTypeLayout::readRecord(scratch, declID);
|
|
|
|
assocTypes.push_back(cast<AssociatedTypeDecl>(getDecl(declID)));
|
|
}
|
|
}
|
|
|
|
void ModuleFile::readPrimaryAssociatedTypes(
|
|
SmallVectorImpl<AssociatedTypeDecl *> &assocTypes,
|
|
llvm::BitstreamCursor &Cursor) {
|
|
using namespace decls_block;
|
|
|
|
BCOffsetRAII lastRecordOffset(Cursor);
|
|
SmallVector<uint64_t, 8> scratch;
|
|
StringRef blobData;
|
|
|
|
while (true) {
|
|
lastRecordOffset.reset();
|
|
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(Cursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
break;
|
|
|
|
scratch.clear();
|
|
unsigned recordID = fatalIfUnexpected(
|
|
Cursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != PRIMARY_ASSOCIATED_TYPE)
|
|
break;
|
|
|
|
DeclID declID;
|
|
PrimaryAssociatedTypeLayout::readRecord(scratch, declID);
|
|
|
|
assocTypes.push_back(cast<AssociatedTypeDecl>(getDecl(declID)));
|
|
}
|
|
}
|
|
|
|
static llvm::Error skipRecords(llvm::BitstreamCursor &Cursor, unsigned kind) {
|
|
using namespace decls_block;
|
|
|
|
BCOffsetRAII lastRecordOffset(Cursor);
|
|
|
|
while (true) {
|
|
Expected<llvm::BitstreamEntry> maybeEntry =
|
|
Cursor.advance(AF_DontPopBlockAtEnd);
|
|
if (!maybeEntry)
|
|
return maybeEntry.takeError();
|
|
llvm::BitstreamEntry entry = maybeEntry.get();
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
break;
|
|
|
|
Expected<unsigned> maybeRecordID = Cursor.skipRecord(entry.ID);
|
|
if (!maybeRecordID)
|
|
return maybeRecordID.takeError();
|
|
if (maybeRecordID.get() != kind)
|
|
return llvm::Error::success();
|
|
|
|
lastRecordOffset.reset();
|
|
}
|
|
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
/// Advances past any records that might be part of a protocol requirement
|
|
/// signature, which consists of generic requirements together with protocol
|
|
/// typealias records.
|
|
static llvm::Error skipRequirementSignature(llvm::BitstreamCursor &Cursor) {
|
|
using namespace decls_block;
|
|
|
|
return skipRecords(Cursor, REQUIREMENT_SIGNATURE);
|
|
}
|
|
|
|
/// Advances past any lazy associated type member records.
|
|
static llvm::Error skipAssociatedTypeMembers(llvm::BitstreamCursor &Cursor) {
|
|
using namespace decls_block;
|
|
|
|
return skipRecords(Cursor, ASSOCIATED_TYPE);
|
|
}
|
|
|
|
/// Advances past any lazy primary associated type member records.
|
|
static llvm::Error skipPrimaryAssociatedTypeMembers(
|
|
llvm::BitstreamCursor &Cursor) {
|
|
using namespace decls_block;
|
|
|
|
return skipRecords(Cursor, PRIMARY_ASSOCIATED_TYPE);
|
|
}
|
|
|
|
GenericSignature ModuleFile::getGenericSignature(
|
|
serialization::GenericSignatureID ID) {
|
|
auto signature = getGenericSignatureChecked(ID);
|
|
if (!signature)
|
|
fatal(signature.takeError());
|
|
return signature.get();
|
|
}
|
|
|
|
Expected<GenericSignature>
|
|
ModuleFile::getGenericSignatureChecked(serialization::GenericSignatureID ID) {
|
|
using namespace decls_block;
|
|
|
|
// Zero is a sentinel for having no generic signature.
|
|
if (ID == 0) return nullptr;
|
|
|
|
assert(ID <= GenericSignatures.size() &&
|
|
"invalid GenericSignature ID");
|
|
auto &sigOffset = GenericSignatures[ID-1];
|
|
|
|
// If we've already deserialized this generic signature, return it.
|
|
if (sigOffset.isComplete())
|
|
return sigOffset.get();
|
|
|
|
// Read the generic signature.
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error =
|
|
diagnoseFatalIfNotSuccess(DeclTypeCursor.JumpToBit(sigOffset)))
|
|
return std::move(error);
|
|
|
|
// Read the parameter types.
|
|
SmallVector<GenericTypeParamType *, 4> paramTypes;
|
|
StringRef blobData;
|
|
SmallVector<uint64_t, 8> scratch;
|
|
|
|
auto entry_or_err = DeclTypeCursor.advance(AF_DontPopBlockAtEnd);
|
|
if (!entry_or_err)
|
|
return diagnoseFatal(entry_or_err.takeError());
|
|
llvm::BitstreamEntry entry = *entry_or_err;
|
|
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return diagnoseFatal();
|
|
|
|
// Helper function to read the generic requirements off the
|
|
// front of the given opaque record.
|
|
SmallVector<Requirement, 4> requirements;
|
|
auto readGenericRequirements =
|
|
[&](ArrayRef<uint64_t> &rawParamIDs) -> llvm::Error {
|
|
unsigned nextIndex = 0;
|
|
auto error = deserializeGenericRequirementsChecked(rawParamIDs, nextIndex,
|
|
requirements);
|
|
rawParamIDs = rawParamIDs.slice(nextIndex);
|
|
return error;
|
|
};
|
|
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
switch (recordID) {
|
|
case GENERIC_SIGNATURE: {
|
|
ArrayRef<uint64_t> rawParamIDs;
|
|
GenericSignatureLayout::readRecord(scratch, rawParamIDs);
|
|
|
|
if (auto error = readGenericRequirements(rawParamIDs))
|
|
return std::move(error);
|
|
|
|
for (unsigned i = 0, n = rawParamIDs.size(); i != n; ++i) {
|
|
auto paramTy = getType(rawParamIDs[i])->castTo<GenericTypeParamType>();
|
|
paramTypes.push_back(paramTy);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case SIL_GENERIC_SIGNATURE: {
|
|
ArrayRef<uint64_t> rawParamIDs;
|
|
SILGenericSignatureLayout::readRecord(scratch, rawParamIDs);
|
|
|
|
if (auto error = readGenericRequirements(rawParamIDs))
|
|
return std::move(error);
|
|
|
|
if (rawParamIDs.size() % 2 != 0)
|
|
return diagnoseFatal();
|
|
|
|
for (unsigned i = 0, n = rawParamIDs.size(); i != n; i += 2) {
|
|
Identifier name = getIdentifier(rawParamIDs[i]);
|
|
auto paramTy = getType(rawParamIDs[i+1])->castTo<GenericTypeParamType>();
|
|
|
|
if (!name.empty()) {
|
|
paramTy = GenericTypeParamType::get(name, paramTy->getParamKind(),
|
|
paramTy->getDepth(),
|
|
paramTy->getIndex(),
|
|
paramTy->getValueType(),
|
|
getContext());
|
|
}
|
|
|
|
paramTypes.push_back(paramTy);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
// Not a generic signature; no way to recover.
|
|
return diagnoseFatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
}
|
|
|
|
// If we've already deserialized this generic signature, start over to return
|
|
// it directly.
|
|
// FIXME: Is this kind of re-entrancy actually possible?
|
|
if (sigOffset.isComplete())
|
|
return getGenericSignature(ID);
|
|
|
|
// Construct the generic signature from the loaded parameters and
|
|
// requirements.
|
|
auto signature = GenericSignature::get(paramTypes, requirements);
|
|
sigOffset = signature;
|
|
return signature;
|
|
}
|
|
|
|
Expected<GenericEnvironment *> ModuleFile::getGenericEnvironmentChecked(
|
|
serialization::GenericEnvironmentID ID) {
|
|
using namespace decls_block;
|
|
|
|
assert(ID <= GenericEnvironments.size() &&
|
|
"invalid GenericEnvironment ID");
|
|
auto &envOffset = GenericEnvironments[ID-1];
|
|
|
|
// If we've already deserialized this generic environment, return it.
|
|
if (envOffset.isComplete())
|
|
return envOffset.get();
|
|
|
|
// Read the generic environment.
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error =
|
|
diagnoseFatalIfNotSuccess(DeclTypeCursor.JumpToBit(envOffset)))
|
|
return std::move(error);
|
|
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return diagnoseFatal();
|
|
|
|
StringRef blobData;
|
|
SmallVector<uint64_t, 8> scratch;
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != GENERIC_ENVIRONMENT)
|
|
fatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
|
|
unsigned kind;
|
|
GenericSignatureID genericSigID;
|
|
TypeID existentialOrShapeID;
|
|
SubstitutionMapID subsID;
|
|
GenericEnvironmentLayout::readRecord(scratch, kind, existentialOrShapeID,
|
|
genericSigID, subsID);
|
|
|
|
auto existentialOrShapeTypeOrError = getTypeChecked(existentialOrShapeID);
|
|
if (!existentialOrShapeTypeOrError)
|
|
return existentialOrShapeTypeOrError.takeError();
|
|
|
|
auto genericSigOrError = getGenericSignatureChecked(genericSigID);
|
|
if (!genericSigOrError)
|
|
return genericSigOrError.takeError();
|
|
|
|
auto contextSubsOrError = getSubstitutionMapChecked(subsID);
|
|
if (!contextSubsOrError)
|
|
return contextSubsOrError.takeError();
|
|
|
|
GenericEnvironment *genericEnv = nullptr;
|
|
switch (GenericEnvironmentKind(kind)) {
|
|
case GenericEnvironmentKind::OpenedExistential:
|
|
genericEnv = GenericEnvironment::forOpenedExistential(
|
|
genericSigOrError.get(),
|
|
existentialOrShapeTypeOrError.get(),
|
|
contextSubsOrError.get(),
|
|
UUID::fromTime());
|
|
break;
|
|
|
|
case GenericEnvironmentKind::OpenedElement:
|
|
genericEnv = GenericEnvironment::forOpenedElement(
|
|
genericSigOrError.get(), UUID::fromTime(),
|
|
cast<GenericTypeParamType>(
|
|
existentialOrShapeTypeOrError.get()->getCanonicalType()),
|
|
contextSubsOrError.get());
|
|
}
|
|
|
|
envOffset = genericEnv;
|
|
|
|
return genericEnv;
|
|
}
|
|
|
|
SubstitutionMap ModuleFile::getSubstitutionMap(
|
|
serialization::SubstitutionMapID id) {
|
|
auto map = getSubstitutionMapChecked(id);
|
|
if (!map)
|
|
fatal(map.takeError());
|
|
return map.get();
|
|
}
|
|
|
|
Expected<SubstitutionMap>
|
|
ModuleFile::getSubstitutionMapChecked(serialization::SubstitutionMapID id) {
|
|
using namespace decls_block;
|
|
|
|
// Zero is a sentinel for having an empty substitution map.
|
|
if (id == 0) return SubstitutionMap();
|
|
|
|
assert(id <= SubstitutionMaps.size() && "invalid SubstitutionMap ID");
|
|
auto &substitutionsOrOffset = SubstitutionMaps[id-1];
|
|
|
|
// If we've already deserialized this substitution map, return it.
|
|
if (substitutionsOrOffset.isComplete()) {
|
|
return substitutionsOrOffset.get();
|
|
}
|
|
|
|
// Read the substitution map.
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error = diagnoseFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(substitutionsOrOffset)))
|
|
return std::move(error);
|
|
|
|
// Read the substitution map.
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return diagnoseFatal();
|
|
|
|
StringRef blobData;
|
|
SmallVector<uint64_t, 8> scratch;
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != SUBSTITUTION_MAP)
|
|
return diagnoseFatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
|
|
GenericSignatureID genericSigID;
|
|
uint64_t numReplacementIDs;
|
|
ArrayRef<uint64_t> typeAndConformanceIDs;
|
|
SubstitutionMapLayout::readRecord(scratch, genericSigID, numReplacementIDs,
|
|
typeAndConformanceIDs);
|
|
auto replacementTypeIDs = typeAndConformanceIDs.slice(0, numReplacementIDs);
|
|
auto conformanceIDs = typeAndConformanceIDs.slice(numReplacementIDs);
|
|
|
|
// Generic signature.
|
|
auto genericSigOrError = getGenericSignatureChecked(genericSigID);
|
|
if (!genericSigOrError)
|
|
return genericSigOrError.takeError();
|
|
|
|
auto genericSig = genericSigOrError.get();
|
|
if (!genericSig)
|
|
return diagnoseFatal();
|
|
|
|
// Load the replacement types.
|
|
SmallVector<Type, 4> replacementTypes;
|
|
replacementTypes.reserve(replacementTypeIDs.size());
|
|
for (auto typeID : replacementTypeIDs) {
|
|
auto typeOrError = getTypeChecked(typeID);
|
|
if (!typeOrError) {
|
|
diagnoseAndConsumeError(typeOrError.takeError());
|
|
continue;
|
|
}
|
|
replacementTypes.push_back(typeOrError.get());
|
|
}
|
|
|
|
// Read the conformances.
|
|
SmallVector<ProtocolConformanceRef, 4> conformances;
|
|
conformances.reserve(conformanceIDs.size());
|
|
for (unsigned conformanceID : conformanceIDs) {
|
|
auto conformanceOrError = getConformanceChecked(conformanceID);
|
|
if (!conformanceOrError)
|
|
return conformanceOrError.takeError();
|
|
conformances.push_back(conformanceOrError.get());
|
|
}
|
|
|
|
// Form the substitution map and record it.
|
|
auto substitutions =
|
|
SubstitutionMap::get(genericSig, ArrayRef<Type>(replacementTypes),
|
|
ArrayRef<ProtocolConformanceRef>(conformances));
|
|
substitutionsOrOffset = substitutions;
|
|
return substitutions;
|
|
}
|
|
|
|
bool ModuleFile::readInheritedProtocols(
|
|
SmallVectorImpl<ProtocolDecl *> &inherited) {
|
|
using namespace decls_block;
|
|
|
|
BCOffsetRAII lastRecordOffset(DeclTypeCursor);
|
|
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return false;
|
|
|
|
SmallVector<uint64_t, 8> scratch;
|
|
unsigned recordID =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(entry.ID, scratch));
|
|
if (recordID != INHERITED_PROTOCOLS)
|
|
return false;
|
|
|
|
lastRecordOffset.reset();
|
|
|
|
ArrayRef<uint64_t> inheritedIDs;
|
|
InheritedProtocolsLayout::readRecord(scratch, inheritedIDs);
|
|
|
|
llvm::transform(inheritedIDs, std::back_inserter(inherited),
|
|
[&](uint64_t protocolID) {
|
|
return cast<ProtocolDecl>(getDecl(protocolID));
|
|
});
|
|
return true;
|
|
}
|
|
|
|
bool ModuleFile::readDefaultWitnessTable(ProtocolDecl *proto) {
|
|
using namespace decls_block;
|
|
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return true;
|
|
|
|
SmallVector<uint64_t, 16> witnessIDBuffer;
|
|
|
|
unsigned kind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(entry.ID, witnessIDBuffer));
|
|
assert(kind == DEFAULT_WITNESS_TABLE);
|
|
(void)kind;
|
|
|
|
ArrayRef<uint64_t> rawWitnessIDs;
|
|
decls_block::DefaultWitnessTableLayout::readRecord(
|
|
witnessIDBuffer, rawWitnessIDs);
|
|
|
|
if (rawWitnessIDs.empty())
|
|
return false;
|
|
|
|
unsigned e = rawWitnessIDs.size();
|
|
assert(e % 2 == 0 && "malformed default witness table");
|
|
(void) e;
|
|
|
|
for (unsigned i = 0, e = rawWitnessIDs.size(); i < e; i += 2) {
|
|
ValueDecl *requirement = cast<ValueDecl>(getDecl(rawWitnessIDs[i]));
|
|
assert(requirement && "unable to deserialize next requirement");
|
|
ValueDecl *witness = cast<ValueDecl>(getDecl(rawWitnessIDs[i + 1]));
|
|
assert(witness && "unable to deserialize next witness");
|
|
assert(requirement->getDeclContext() == proto);
|
|
|
|
proto->setDefaultWitness(requirement, witness);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static std::optional<swift::CtorInitializerKind>
|
|
getActualCtorInitializerKind(uint8_t raw) {
|
|
switch (serialization::CtorInitializerKind(raw)) {
|
|
#define CASE(NAME) \
|
|
case serialization::CtorInitializerKind::NAME: \
|
|
return swift::CtorInitializerKind::NAME;
|
|
CASE(Designated)
|
|
CASE(Convenience)
|
|
CASE(Factory)
|
|
CASE(ConvenienceFactory)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static bool isReExportedToModule(const ValueDecl *value,
|
|
const ModuleDecl *expectedModule) {
|
|
const DeclContext *valueDC = value->getDeclContext();
|
|
auto fromClangModule
|
|
= dyn_cast<ClangModuleUnit>(valueDC->getModuleScopeContext());
|
|
if (!fromClangModule)
|
|
return false;
|
|
StringRef exportedName = fromClangModule->getExportedModuleName();
|
|
|
|
auto toClangModule
|
|
= dyn_cast<ClangModuleUnit>(expectedModule->getFiles().front());
|
|
if (toClangModule)
|
|
return exportedName == toClangModule->getExportedModuleName();
|
|
return exportedName == expectedModule->getName().str();
|
|
}
|
|
|
|
namespace {
|
|
/// The result of a type comparison.
|
|
enum class TypeComparison {
|
|
NotEqual,
|
|
Equal,
|
|
NearMatch,
|
|
};
|
|
|
|
TypeComparison compareTypes(CanType type1, CanType type2, bool nearMatchOk) {
|
|
if (type1->isEqual(type2))
|
|
return TypeComparison::Equal;
|
|
|
|
if (nearMatchOk) {
|
|
TypeMatchOptions options = TypeMatchFlags::RequireMatchingParameterLabels;
|
|
options |= TypeMatchFlags::AllowTopLevelOptionalMismatch;
|
|
options |= TypeMatchFlags::AllowNonOptionalForIUOParam;
|
|
options |= TypeMatchFlags::IgnoreNonEscapingForOptionalFunctionParam;
|
|
options |= TypeMatchFlags::IgnoreFunctionSendability;
|
|
options |= TypeMatchFlags::IgnoreSendability;
|
|
options |= TypeMatchFlags::IgnoreFunctionGlobalActorIsolation;
|
|
if (type1->matches(type2, options))
|
|
return TypeComparison::NearMatch;
|
|
}
|
|
|
|
return TypeComparison::NotEqual;
|
|
}
|
|
}
|
|
|
|
/// Remove values from \p values that don't match the expected type or module.
|
|
///
|
|
/// Any of \p expectedTy, \p expectedModule, or \p expectedGenericSig can be
|
|
/// omitted, in which case any type or module is accepted. Values imported
|
|
/// from Clang can also appear in any module.
|
|
static void filterValues(Type expectedTy, ModuleDecl *expectedModule,
|
|
CanGenericSignature expectedGenericSig, bool isType,
|
|
bool inProtocolExt, bool importedFromClang,
|
|
bool isStatic,
|
|
std::optional<swift::CtorInitializerKind> ctorInit,
|
|
SmallVectorImpl<ValueDecl *> &values) {
|
|
CanType canTy;
|
|
if (expectedTy)
|
|
canTy = expectedTy->getCanonicalType();
|
|
|
|
llvm::TinyPtrVector<ValueDecl *> clangNearMatches;
|
|
|
|
auto newEnd = std::remove_if(values.begin(), values.end(),
|
|
[=, &clangNearMatches](ValueDecl *value) {
|
|
// Ignore anything that was parsed (vs. deserialized), because a serialized
|
|
// module cannot refer to it.
|
|
if (value->getDeclContext()->getParentSourceFile())
|
|
return true;
|
|
|
|
if (isType != isa<TypeDecl>(value))
|
|
return true;
|
|
|
|
// If we're expecting a type, make sure this decl has the expected type.
|
|
TypeComparison typesMatch = TypeComparison::Equal;
|
|
if (canTy) {
|
|
typesMatch = compareTypes(canTy,
|
|
value->getInterfaceType()->getCanonicalType(),
|
|
importedFromClang);
|
|
}
|
|
|
|
if (typesMatch == TypeComparison::NotEqual)
|
|
return true;
|
|
|
|
if (value->isStatic() != isStatic)
|
|
return true;
|
|
if (value->hasClangNode() != importedFromClang)
|
|
return true;
|
|
|
|
if (value->getAttrs().hasAttribute<ForbidSerializingReferenceAttr>())
|
|
return true;
|
|
|
|
// FIXME: Should be able to move a value from an extension in a derived
|
|
// module to the original definition in a base module.
|
|
if (expectedModule && !value->hasClangNode() &&
|
|
value->getModuleContext() != expectedModule &&
|
|
!isReExportedToModule(value, expectedModule))
|
|
return true;
|
|
|
|
// If we're expecting a member within a constrained extension with a
|
|
// particular generic signature, match that signature.
|
|
if (expectedGenericSig &&
|
|
value->getDeclContext()
|
|
->getGenericSignatureOfContext()
|
|
.getCanonicalSignature() != expectedGenericSig)
|
|
return true;
|
|
|
|
// If we don't expect a specific generic signature, ignore anything from a
|
|
// constrained extension.
|
|
if (!expectedGenericSig &&
|
|
isa<ExtensionDecl>(value->getDeclContext()) &&
|
|
cast<ExtensionDecl>(value->getDeclContext())->isConstrainedExtension())
|
|
return true;
|
|
|
|
// If we're looking at members of a protocol or protocol extension,
|
|
// filter by whether we expect to find something in a protocol extension or
|
|
// not. This lets us distinguish between a protocol member and a protocol
|
|
// extension member that have the same type.
|
|
if (value->getDeclContext()->getSelfProtocolDecl() &&
|
|
(bool)value->getDeclContext()->getExtendedProtocolDecl()
|
|
!= inProtocolExt)
|
|
return true;
|
|
|
|
// If we're expecting an initializer with a specific kind, and this is not
|
|
// an initializer with that kind, remove it.
|
|
if (ctorInit) {
|
|
if (!isa<ConstructorDecl>(value) ||
|
|
cast<ConstructorDecl>(value)->getInitKind() != *ctorInit)
|
|
return true;
|
|
}
|
|
|
|
// Record near matches.
|
|
if (typesMatch == TypeComparison::NearMatch) {
|
|
clangNearMatches.push_back(value);
|
|
return true;
|
|
}
|
|
|
|
ASSERT(typesMatch == TypeComparison::Equal);
|
|
return false;
|
|
});
|
|
values.erase(newEnd, values.end());
|
|
|
|
if (values.empty())
|
|
values.append(clangNearMatches.begin(), clangNearMatches.end());
|
|
}
|
|
|
|
/// Look for nested types in all files of \p extensionModule except from the \p thisFile.
|
|
static TypeDecl *
|
|
findNestedTypeDeclInModule(FileUnit *thisFile, ModuleDecl *extensionModule,
|
|
Identifier name, NominalTypeDecl *parent) {
|
|
assert(extensionModule && "NULL is not a valid module");
|
|
for (FileUnit *file : extensionModule->getFiles()) {
|
|
if (file == thisFile)
|
|
continue;
|
|
|
|
if (auto nestedType = file->lookupNestedType(name, parent)) {
|
|
return nestedType;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
/// Look for nested types in all files of \p extensionModule.
|
|
static TypeDecl *
|
|
findNestedTypeDeclInModule(ModuleDecl *extensionModule,
|
|
Identifier name, NominalTypeDecl *parent) {
|
|
return findNestedTypeDeclInModule(nullptr, extensionModule, name, parent);
|
|
}
|
|
|
|
Expected<Decl *>
|
|
ModuleFile::resolveCrossReference(ModuleID MID, uint32_t pathLen) {
|
|
using namespace decls_block;
|
|
|
|
ModuleDecl *baseModule = getModule(MID);
|
|
if (!baseModule) {
|
|
return llvm::make_error<XRefNonLoadedModuleError>(getIdentifier(MID));
|
|
}
|
|
|
|
assert(baseModule && "missing dependency");
|
|
PrettyXRefTrace pathTrace(*baseModule);
|
|
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return diagnoseFatal();
|
|
|
|
SmallVector<ValueDecl *, 8> values;
|
|
SmallVector<uint64_t, 8> scratch;
|
|
StringRef blobData;
|
|
|
|
// Read the first path piece. This one is special because lookup is performed
|
|
// against the base module, rather than against the previous link in the path.
|
|
// In particular, operator path pieces represent actual operators here, but
|
|
// filters on operator functions when they appear later on.
|
|
scratch.clear();
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
switch (recordID) {
|
|
case XREF_TYPE_PATH_PIECE:
|
|
case XREF_VALUE_PATH_PIECE: {
|
|
IdentifierID IID;
|
|
IdentifierID privateDiscriminator = 0;
|
|
TypeID TID = 0;
|
|
bool isType = (recordID == XREF_TYPE_PATH_PIECE);
|
|
bool inProtocolExt = false;
|
|
bool importedFromClang = false;
|
|
bool isStatic = false;
|
|
if (isType)
|
|
XRefTypePathPieceLayout::readRecord(scratch, IID, privateDiscriminator,
|
|
inProtocolExt, importedFromClang);
|
|
else
|
|
XRefValuePathPieceLayout::readRecord(scratch, TID, IID, inProtocolExt,
|
|
importedFromClang, isStatic);
|
|
|
|
DeclBaseName name = getDeclBaseName(IID);
|
|
pathTrace.addValue(name);
|
|
if (privateDiscriminator)
|
|
pathTrace.addValue(getIdentifier(privateDiscriminator));
|
|
|
|
Type filterTy;
|
|
if (!isType) {
|
|
auto maybeType = getTypeChecked(TID);
|
|
if (!maybeType) {
|
|
// Pass through deserialization errors.
|
|
if (maybeType.errorIsA<FatalDeserializationError>())
|
|
return maybeType.takeError();
|
|
// FIXME: Don't throw away the inner error's information.
|
|
diagnoseAndConsumeError(maybeType.takeError());
|
|
return llvm::make_error<XRefError>("couldn't decode type",
|
|
pathTrace, name);
|
|
}
|
|
filterTy = maybeType.get();
|
|
pathTrace.addType(filterTy);
|
|
}
|
|
|
|
if (privateDiscriminator) {
|
|
baseModule->lookupMember(values, baseModule, name,
|
|
getIdentifier(privateDiscriminator));
|
|
} else {
|
|
baseModule->lookupQualified(baseModule, DeclNameRef(name),
|
|
SourceLoc(), NL_RemoveOverridden,
|
|
values);
|
|
}
|
|
filterValues(filterTy, nullptr, nullptr, isType, inProtocolExt,
|
|
importedFromClang, isStatic, std::nullopt, values);
|
|
if (values.empty() && importedFromClang && name.isOperator() && filterTy) {
|
|
// This could be a Clang-importer instantiated/synthesized conformance
|
|
// operator, like '==', '-' or '+=', that are required for conformances to
|
|
// one of the Cxx iterator protocols. Attempt to resolve it using clang importer
|
|
// lookup logic for the given type instead of looking for it in the module.
|
|
if (auto *fty = dyn_cast<AnyFunctionType>(filterTy.getPointer())) {
|
|
if (fty->getNumParams()) {
|
|
assert(fty->getNumParams() <= 2);
|
|
auto p = fty->getParams()[0].getParameterType();
|
|
if (auto sty = dyn_cast<NominalType>(p.getPointer())) {
|
|
if (auto *op = importer::getImportedMemberOperator(
|
|
name, sty->getDecl(),
|
|
fty->getNumParams() > 1
|
|
? fty->getParams()[1].getParameterType()
|
|
: std::optional<Type>{}))
|
|
values.push_back(op);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case XREF_OPAQUE_RETURN_TYPE_PATH_PIECE: {
|
|
IdentifierID DefiningDeclNameID;
|
|
|
|
XRefOpaqueReturnTypePathPieceLayout::readRecord(scratch, DefiningDeclNameID);
|
|
|
|
auto name = getIdentifier(DefiningDeclNameID);
|
|
pathTrace.addOpaqueReturnType(name);
|
|
|
|
if (auto opaque = baseModule->lookupOpaqueResultType(name.str())) {
|
|
values.push_back(opaque);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case XREF_EXTENSION_PATH_PIECE:
|
|
llvm_unreachable("can only extend a nominal");
|
|
|
|
case XREF_OPERATOR_OR_ACCESSOR_PATH_PIECE: {
|
|
IdentifierID IID;
|
|
uint8_t rawOpKind;
|
|
XRefOperatorOrAccessorPathPieceLayout::readRecord(scratch, IID, rawOpKind);
|
|
|
|
Identifier opName = getIdentifier(IID);
|
|
pathTrace.addOperator(opName);
|
|
|
|
auto &ctx = getContext();
|
|
auto desc = OperatorLookupDescriptor::forModule(baseModule, opName);
|
|
switch (rawOpKind) {
|
|
case OperatorKind::Infix:
|
|
case OperatorKind::Prefix:
|
|
case OperatorKind::Postfix: {
|
|
auto req = DirectOperatorLookupRequest{
|
|
desc, getASTOperatorFixity(static_cast<OperatorKind>(rawOpKind))};
|
|
auto results = evaluateOrDefault(ctx.evaluator, req, {});
|
|
if (results.size() != 1) {
|
|
return llvm::make_error<XRefError>("operator not found", pathTrace,
|
|
opName);
|
|
}
|
|
return results[0];
|
|
}
|
|
case OperatorKind::PrecedenceGroup: {
|
|
auto results = evaluateOrDefault(
|
|
ctx.evaluator, DirectPrecedenceGroupLookupRequest{desc}, {});
|
|
if (results.size() != 1) {
|
|
return llvm::make_error<XRefError>("precedencegroup not found",
|
|
pathTrace, opName);
|
|
}
|
|
return results[0];
|
|
}
|
|
default:
|
|
// Unknown operator kind.
|
|
return diagnoseFatal();
|
|
}
|
|
llvm_unreachable("Unhandled case in switch!");
|
|
}
|
|
|
|
case XREF_GENERIC_PARAM_PATH_PIECE:
|
|
case XREF_INITIALIZER_PATH_PIECE:
|
|
llvm_unreachable("only in a nominal or function");
|
|
|
|
default:
|
|
// Unknown xref kind.
|
|
pathTrace.addUnknown(recordID);
|
|
fatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
}
|
|
|
|
auto getXRefDeclNameForError = [&]() -> DeclName {
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
DeclName result = pathTrace.getLastName();
|
|
uint32_t namePathLen = pathLen;
|
|
while (--namePathLen) {
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return Identifier();
|
|
|
|
scratch.clear();
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
switch (recordID) {
|
|
case XREF_TYPE_PATH_PIECE: {
|
|
IdentifierID IID;
|
|
XRefTypePathPieceLayout::readRecord(scratch, IID, std::nullopt,
|
|
std::nullopt, std::nullopt);
|
|
result = getIdentifier(IID);
|
|
break;
|
|
}
|
|
case XREF_VALUE_PATH_PIECE: {
|
|
IdentifierID IID;
|
|
XRefValuePathPieceLayout::readRecord(scratch, std::nullopt, IID,
|
|
std::nullopt, std::nullopt,
|
|
std::nullopt);
|
|
result = getIdentifier(IID);
|
|
break;
|
|
}
|
|
case XREF_OPAQUE_RETURN_TYPE_PATH_PIECE: {
|
|
IdentifierID IID;
|
|
XRefOpaqueReturnTypePathPieceLayout::readRecord(scratch, IID);
|
|
auto mangledName = getIdentifier(IID);
|
|
|
|
SmallString<64> buf;
|
|
{
|
|
llvm::raw_svector_ostream os(buf);
|
|
os << "<<opaque return type of ";
|
|
os << mangledName.str();
|
|
os << ">>";
|
|
}
|
|
|
|
result = getContext().getIdentifier(buf);
|
|
break;
|
|
}
|
|
case XREF_INITIALIZER_PATH_PIECE:
|
|
result = DeclBaseName::createConstructor();
|
|
break;
|
|
|
|
case XREF_EXTENSION_PATH_PIECE:
|
|
case XREF_OPERATOR_OR_ACCESSOR_PATH_PIECE:
|
|
break;
|
|
|
|
case XREF_GENERIC_PARAM_PATH_PIECE:
|
|
// Can't get the name without deserializing.
|
|
result = Identifier();
|
|
break;
|
|
|
|
default:
|
|
// Unknown encoding.
|
|
return Identifier();
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
|
|
if (values.empty()) {
|
|
// Couldn't resolve the reference. Try to explain the problem and leave it
|
|
// up to the caller to recover if possible.
|
|
|
|
// Look for types and value decls in other modules. This extra information
|
|
// will be used for diagnostics by the caller logic.
|
|
SmallVector<char, 64> strScratch;
|
|
|
|
auto errorKind = ModularizationError::Kind::DeclNotFound;
|
|
ModuleDecl *foundIn = nullptr;
|
|
std::optional<std::pair<Type, Type>> mismatchingTypes;
|
|
bool isType = false;
|
|
|
|
if (recordID == XREF_TYPE_PATH_PIECE ||
|
|
recordID == XREF_VALUE_PATH_PIECE) {
|
|
auto &ctx = getContext();
|
|
for (auto nameAndModule : ctx.getLoadedModules()) {
|
|
auto otherModule = nameAndModule.second;
|
|
|
|
IdentifierID IID;
|
|
IdentifierID privateDiscriminator = 0;
|
|
TypeID TID = 0;
|
|
isType = (recordID == XREF_TYPE_PATH_PIECE);
|
|
bool inProtocolExt = false;
|
|
bool importedFromClang = false;
|
|
bool isStatic = false;
|
|
if (isType) {
|
|
XRefTypePathPieceLayout::readRecord(scratch, IID, privateDiscriminator,
|
|
inProtocolExt, importedFromClang);
|
|
} else {
|
|
XRefValuePathPieceLayout::readRecord(scratch, TID, IID, inProtocolExt,
|
|
importedFromClang, isStatic);
|
|
}
|
|
|
|
DeclBaseName name = getDeclBaseName(IID);
|
|
Type filterTy;
|
|
if (!isType) {
|
|
auto maybeType = getTypeChecked(TID);
|
|
// Any error here would have been handled previously.
|
|
if (maybeType) {
|
|
filterTy = maybeType.get();
|
|
}
|
|
}
|
|
|
|
values.clear();
|
|
if (privateDiscriminator) {
|
|
otherModule->lookupMember(values, otherModule, name,
|
|
getIdentifier(privateDiscriminator));
|
|
} else {
|
|
otherModule->lookupQualified(otherModule, DeclNameRef(name),
|
|
SourceLoc(), NL_RemoveOverridden,
|
|
values);
|
|
}
|
|
|
|
std::optional<ValueDecl*> matchBeforeFiltering = std::nullopt;
|
|
if (!values.empty()) {
|
|
matchBeforeFiltering = values[0];
|
|
}
|
|
filterValues(filterTy, nullptr, nullptr, isType, inProtocolExt,
|
|
importedFromClang, isStatic, std::nullopt, values);
|
|
|
|
strScratch.clear();
|
|
if (!values.empty()) {
|
|
// Found a full match in a different module. It should be a different
|
|
// one because otherwise it would have succeeded on the first search.
|
|
// This is usually caused by the use of poorly modularized headers.
|
|
errorKind = ModularizationError::Kind::DeclMoved;
|
|
foundIn = otherModule;
|
|
break;
|
|
} else if (matchBeforeFiltering.has_value()) {
|
|
// Found a match that was filtered out. This may be from the same
|
|
// expected module if there's a type difference. This can be caused
|
|
// by the use of different Swift language versions between a library
|
|
// with serialized SIL and a client.
|
|
errorKind = ModularizationError::Kind::DeclKindChanged;
|
|
foundIn = otherModule;
|
|
|
|
if (filterTy) {
|
|
auto expectedTy = filterTy->getCanonicalType();
|
|
auto foundTy = (*matchBeforeFiltering)->getInterfaceType();
|
|
if (expectedTy && foundTy && !expectedTy->isEqual(foundTy))
|
|
mismatchingTypes = std::make_pair(expectedTy, foundTy);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
auto declName = getXRefDeclNameForError();
|
|
auto error = llvm::make_error<ModularizationError>(declName,
|
|
isType,
|
|
errorKind,
|
|
baseModule,
|
|
this,
|
|
foundIn,
|
|
pathTrace,
|
|
mismatchingTypes);
|
|
|
|
// If we want to workaround broken modularization, we can keep going if
|
|
// we found a matching top-level decl in a different module. This is
|
|
// obviously dangerous as it could just be some other decl that happens to
|
|
// match.
|
|
if (getContext().LangOpts.ForceWorkaroundBrokenModules &&
|
|
errorKind == ModularizationError::Kind::DeclMoved &&
|
|
!values.empty()) {
|
|
// Print the error as a warning and notify of the recovery attempt.
|
|
llvm::handleAllErrors(std::move(error),
|
|
[&](const ModularizationError &modularError) {
|
|
modularError.diagnose(this, DiagnosticBehavior::Warning);
|
|
});
|
|
getContext().Diags.diagnose(SourceLoc(),
|
|
diag::modularization_issue_worked_around);
|
|
} else {
|
|
return std::move(error);
|
|
}
|
|
}
|
|
|
|
// Filters for values discovered in the remaining path pieces.
|
|
ModuleDecl *M = nullptr;
|
|
CanGenericSignature genericSig = CanGenericSignature();
|
|
|
|
// For remaining path pieces, filter or drill down into the results we have.
|
|
while (--pathLen) {
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return diagnoseFatal();
|
|
|
|
scratch.clear();
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
switch (recordID) {
|
|
case XREF_TYPE_PATH_PIECE: {
|
|
if (values.size() == 1 && isa<NominalTypeDecl>(values.front())) {
|
|
// Fast path for nested types that avoids deserializing all
|
|
// members of the parent type.
|
|
IdentifierID IID;
|
|
IdentifierID privateDiscriminator;
|
|
bool importedFromClang = false;
|
|
bool inProtocolExt = false;
|
|
XRefTypePathPieceLayout::readRecord(scratch, IID, privateDiscriminator,
|
|
inProtocolExt, importedFromClang);
|
|
if (privateDiscriminator)
|
|
goto giveUpFastPath;
|
|
|
|
Identifier memberName = getIdentifier(IID);
|
|
pathTrace.addValue(memberName);
|
|
|
|
auto *baseType = cast<NominalTypeDecl>(values.front());
|
|
ModuleDecl *extensionModule = M;
|
|
if (!extensionModule)
|
|
extensionModule = baseType->getModuleContext();
|
|
|
|
// Fault in extensions, then ask every file in the module.
|
|
// We include the current file in the search because the cross reference
|
|
// may involve a nested type of this file.
|
|
(void)baseType->getExtensions();
|
|
auto *nestedType =
|
|
findNestedTypeDeclInModule(extensionModule, memberName, baseType);
|
|
|
|
// For clang module units, also search tables in the overlays.
|
|
if (!nestedType) {
|
|
if (auto LF =
|
|
dyn_cast<LoadedFile>(baseType->getModuleScopeContext())) {
|
|
if (auto overlayModule = LF->getOverlayModule()) {
|
|
nestedType = findNestedTypeDeclInModule(getFile(), overlayModule,
|
|
memberName, baseType);
|
|
} else if (LF->getParentModule() != extensionModule) {
|
|
nestedType = findNestedTypeDeclInModule(getFile(),
|
|
LF->getParentModule(),
|
|
memberName, baseType);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nestedType) {
|
|
SmallVector<ValueDecl *, 1> singleValueBuffer{nestedType};
|
|
filterValues(/*expectedTy*/ Type(), extensionModule, genericSig,
|
|
/*isType*/ true, inProtocolExt, importedFromClang,
|
|
/*isStatic*/ false, /*ctorInit*/ std::nullopt,
|
|
singleValueBuffer);
|
|
if (!singleValueBuffer.empty()) {
|
|
values.assign({nestedType});
|
|
++NumNestedTypeShortcuts;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pathTrace.removeLast();
|
|
}
|
|
giveUpFastPath:
|
|
LLVM_FALLTHROUGH;
|
|
}
|
|
case XREF_VALUE_PATH_PIECE:
|
|
case XREF_INITIALIZER_PATH_PIECE: {
|
|
TypeID TID = 0;
|
|
DeclBaseName memberName;
|
|
Identifier privateDiscriminator;
|
|
std::optional<swift::CtorInitializerKind> ctorInit;
|
|
bool isType = false;
|
|
bool inProtocolExt = false;
|
|
bool importedFromClang = false;
|
|
bool isStatic = false;
|
|
switch (recordID) {
|
|
case XREF_TYPE_PATH_PIECE: {
|
|
IdentifierID IID, discriminatorID;
|
|
XRefTypePathPieceLayout::readRecord(scratch, IID, discriminatorID,
|
|
inProtocolExt, importedFromClang);
|
|
memberName = getDeclBaseName(IID);
|
|
privateDiscriminator = getIdentifier(discriminatorID);
|
|
isType = true;
|
|
break;
|
|
}
|
|
|
|
case XREF_VALUE_PATH_PIECE: {
|
|
IdentifierID IID;
|
|
XRefValuePathPieceLayout::readRecord(scratch, TID, IID, inProtocolExt,
|
|
importedFromClang, isStatic);
|
|
memberName = getDeclBaseName(IID);
|
|
break;
|
|
}
|
|
|
|
case XREF_INITIALIZER_PATH_PIECE: {
|
|
uint8_t kind;
|
|
XRefInitializerPathPieceLayout::readRecord(scratch, TID, inProtocolExt,
|
|
importedFromClang, kind);
|
|
memberName = DeclBaseName::createConstructor();
|
|
ctorInit = getActualCtorInitializerKind(kind);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
fatal(llvm::make_error<InvalidRecordKindError>(recordID,
|
|
"Unhandled path piece"));
|
|
}
|
|
|
|
pathTrace.addValue(memberName);
|
|
if (!privateDiscriminator.empty())
|
|
pathTrace.addPrivateDiscriminator(privateDiscriminator);
|
|
|
|
Type filterTy;
|
|
if (!isType) {
|
|
auto maybeType = getTypeChecked(TID);
|
|
if (!maybeType) {
|
|
// Pass through deserialization errors.`
|
|
if (maybeType.errorIsA<FatalDeserializationError>())
|
|
return maybeType.takeError();
|
|
|
|
// FIXME: Don't throw away the inner error's information.
|
|
diagnoseAndConsumeError(maybeType.takeError());
|
|
return llvm::make_error<XRefError>("couldn't decode type",
|
|
pathTrace, memberName);
|
|
}
|
|
filterTy = maybeType.get();
|
|
pathTrace.addType(filterTy);
|
|
}
|
|
|
|
if (values.size() != 1) {
|
|
return llvm::make_error<XRefError>("multiple matching base values",
|
|
pathTrace,
|
|
getXRefDeclNameForError());
|
|
}
|
|
|
|
auto nominal = dyn_cast<NominalTypeDecl>(values.front());
|
|
values.clear();
|
|
|
|
if (!nominal) {
|
|
return llvm::make_error<XRefError>("base is not a nominal type",
|
|
pathTrace,
|
|
getXRefDeclNameForError());
|
|
}
|
|
|
|
if (memberName.getKind() == DeclBaseName::Kind::Destructor) {
|
|
assert(isa<ClassDecl>(nominal));
|
|
// Force creation of an implicit destructor
|
|
auto CD = dyn_cast<ClassDecl>(nominal);
|
|
values.push_back(CD->getDestructor());
|
|
break;
|
|
}
|
|
|
|
if (!privateDiscriminator.empty()) {
|
|
if (importedFromClang) {
|
|
// This is a clang imported class template, that's
|
|
// serialized using original template name, and
|
|
// its USR that denotes the specific specialization.
|
|
auto members = nominal->lookupDirect(memberName);
|
|
for (const auto &m : members) {
|
|
if (!m->hasClangNode())
|
|
continue;
|
|
if (auto *ctd =
|
|
dyn_cast<clang::ClassTemplateDecl>(m->getClangDecl())) {
|
|
for (const auto *spec : ctd->specializations()) {
|
|
llvm::SmallString<128> buffer;
|
|
clang::index::generateUSRForDecl(spec, buffer);
|
|
if (privateDiscriminator.str() == buffer) {
|
|
if (auto import = getContext()
|
|
.getClangModuleLoader()
|
|
->importDeclDirectly(spec))
|
|
values.push_back(cast<ValueDecl>(import));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
ModuleDecl *searchModule = M;
|
|
if (!searchModule)
|
|
searchModule = nominal->getModuleContext();
|
|
searchModule->lookupMember(values, nominal, memberName,
|
|
privateDiscriminator);
|
|
}
|
|
} else {
|
|
auto members = nominal->lookupDirect(memberName);
|
|
values.append(members.begin(), members.end());
|
|
}
|
|
filterValues(filterTy, M, genericSig, isType, inProtocolExt,
|
|
importedFromClang, isStatic, ctorInit, values);
|
|
break;
|
|
}
|
|
|
|
case XREF_EXTENSION_PATH_PIECE: {
|
|
ModuleID ownerID;
|
|
GenericSignatureID rawGenericSig;
|
|
XRefExtensionPathPieceLayout::readRecord(scratch, ownerID, rawGenericSig);
|
|
M = getModule(ownerID);
|
|
if (!M) {
|
|
return llvm::make_error<XRefError>("module with extension is not loaded",
|
|
pathTrace, getIdentifier(ownerID));
|
|
}
|
|
pathTrace.addExtension(M);
|
|
|
|
// Read the generic signature, if we have one.
|
|
genericSig = CanGenericSignature(getGenericSignature(rawGenericSig));
|
|
|
|
continue;
|
|
}
|
|
|
|
case XREF_OPERATOR_OR_ACCESSOR_PATH_PIECE: {
|
|
uint8_t rawKind;
|
|
XRefOperatorOrAccessorPathPieceLayout::readRecord(scratch, std::nullopt,
|
|
rawKind);
|
|
if (values.empty())
|
|
break;
|
|
|
|
if (!values.front()->getBaseName().isOperator()) {
|
|
pathTrace.addAccessor(rawKind);
|
|
if (auto storage = dyn_cast<AbstractStorageDecl>(values.front())) {
|
|
auto actualKind = getActualAccessorKind(rawKind);
|
|
if (!actualKind) {
|
|
// Unknown accessor kind.
|
|
return diagnoseFatal();
|
|
}
|
|
values.front() = storage->getAccessor(*actualKind);
|
|
if (!values.front()) {
|
|
return llvm::make_error<XRefError>("missing accessor",
|
|
pathTrace,
|
|
getXRefDeclNameForError());
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
pathTrace.addOperatorFilter(rawKind);
|
|
|
|
auto newEnd = std::remove_if(values.begin(), values.end(),
|
|
[=](ValueDecl *value) {
|
|
auto fn = dyn_cast<FuncDecl>(value);
|
|
if (!fn)
|
|
return true;
|
|
if (!fn->getOperatorDecl())
|
|
return true;
|
|
if (getStableFixity(fn->getOperatorDecl()->getFixity()) != rawKind)
|
|
return true;
|
|
return false;
|
|
});
|
|
values.erase(newEnd, values.end());
|
|
break;
|
|
}
|
|
|
|
case XREF_GENERIC_PARAM_PATH_PIECE: {
|
|
if (values.size() != 1) {
|
|
return llvm::make_error<XRefError>("multiple matching base values",
|
|
pathTrace,
|
|
getXRefDeclNameForError());
|
|
}
|
|
|
|
uint32_t depth, paramIndex;
|
|
XRefGenericParamPathPieceLayout::readRecord(scratch, depth, paramIndex);
|
|
|
|
pathTrace.addGenericParam(paramIndex);
|
|
|
|
ValueDecl *base = values.front();
|
|
|
|
GenericSignature currentSig;
|
|
if (auto nominal = dyn_cast<NominalTypeDecl>(base)) {
|
|
if (genericSig) {
|
|
// Find an extension in the requested module that has the
|
|
// correct generic signature.
|
|
for (auto ext : nominal->getExtensions()) {
|
|
if (ext->getModuleContext() == M &&
|
|
ext->getGenericSignature().getCanonicalSignature() ==
|
|
genericSig) {
|
|
currentSig = ext->getGenericSignature();
|
|
break;
|
|
}
|
|
}
|
|
assert(currentSig && "Couldn't find constrained extension");
|
|
} else {
|
|
// Simple case: use the nominal type's generic parameters.
|
|
currentSig = nominal->getGenericSignature();
|
|
}
|
|
} else if (auto alias = dyn_cast<TypeAliasDecl>(base)) {
|
|
currentSig = alias->getGenericSignature();
|
|
} else if (auto fn = dyn_cast<AbstractFunctionDecl>(base)) {
|
|
currentSig = fn->getGenericSignature();
|
|
} else if (auto subscript = dyn_cast<SubscriptDecl>(base)) {
|
|
currentSig = subscript->getGenericSignature();
|
|
} else if (auto opaque = dyn_cast<OpaqueTypeDecl>(base)) {
|
|
currentSig = opaque->getGenericSignature();
|
|
}
|
|
|
|
if (!currentSig) {
|
|
return llvm::make_error<XRefError>(
|
|
"cross-reference to generic param for non-generic type",
|
|
pathTrace, getXRefDeclNameForError());
|
|
}
|
|
|
|
bool found = false;
|
|
for (auto paramTy : currentSig.getGenericParams()) {
|
|
if (paramTy->getIndex() == paramIndex &&
|
|
paramTy->getDepth() == depth) {
|
|
values.clear();
|
|
values.push_back(paramTy->getDecl());
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
return llvm::make_error<XRefError>(
|
|
"invalid generic argument index or depth",
|
|
pathTrace, getXRefDeclNameForError());
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case XREF_OPAQUE_RETURN_TYPE_PATH_PIECE: {
|
|
values.clear();
|
|
IdentifierID DefiningDeclNameID;
|
|
|
|
XRefOpaqueReturnTypePathPieceLayout::readRecord(scratch, DefiningDeclNameID);
|
|
|
|
auto name = getIdentifier(DefiningDeclNameID);
|
|
pathTrace.addOpaqueReturnType(name);
|
|
|
|
auto lookupModule = M ? M : baseModule;
|
|
if (auto opaqueTy = lookupModule->lookupOpaqueResultType(name.str())) {
|
|
values.push_back(opaqueTy);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// Unknown xref path piece.
|
|
pathTrace.addUnknown(recordID);
|
|
fatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
}
|
|
|
|
std::optional<PrettyStackTraceModuleFile> traceMsg;
|
|
if (M != getAssociatedModule()) {
|
|
traceMsg.emplace("If you're seeing a crash here, check that your SDK "
|
|
"and dependencies match the versions used to build",
|
|
*this);
|
|
}
|
|
|
|
if (values.empty()) {
|
|
return llvm::make_error<XRefError>("result not found", pathTrace,
|
|
getXRefDeclNameForError());
|
|
}
|
|
|
|
// Reset the module filter.
|
|
M = nullptr;
|
|
genericSig = nullptr;
|
|
}
|
|
|
|
// Make sure we /used/ the last module filter we got.
|
|
// This catches the case where the last path piece we saw was an Extension
|
|
// path piece, which is not a valid way to end a path. (Cross-references to
|
|
// extensions are not allowed because they cannot be uniquely named.)
|
|
if (M)
|
|
return diagnoseFatal();
|
|
|
|
if (values.size() > 1) {
|
|
// Apply shadowing filtering after other local filters so we don't rule out
|
|
// valid candidates shadowed by invalid ones.
|
|
removeShadowedDecls(values, baseModule);
|
|
}
|
|
|
|
// When all is said and done, we should have a single value here to return.
|
|
if (values.size() != 1) {
|
|
return llvm::make_error<XRefError>("result is ambiguous", pathTrace,
|
|
getXRefDeclNameForError());
|
|
}
|
|
|
|
assert(values.front() != nullptr);
|
|
return values.front();
|
|
}
|
|
|
|
DeclBaseName ModuleFile::getDeclBaseName(IdentifierID IID) {
|
|
if (IID == 0)
|
|
return Identifier();
|
|
|
|
if (IID < NUM_SPECIAL_IDS) {
|
|
switch (static_cast<SpecialIdentifierID>(static_cast<uint8_t>(IID))) {
|
|
case BUILTIN_MODULE_ID:
|
|
case CURRENT_MODULE_ID:
|
|
case OBJC_HEADER_MODULE_ID:
|
|
llvm_unreachable("Cannot get DeclBaseName of special module id");
|
|
case SUBSCRIPT_ID:
|
|
return DeclBaseName::createSubscript();
|
|
case serialization::CONSTRUCTOR_ID:
|
|
return DeclBaseName::createConstructor();
|
|
case serialization::DESTRUCTOR_ID:
|
|
return DeclBaseName::createDestructor();
|
|
case NUM_SPECIAL_IDS:
|
|
llvm_unreachable("implementation detail only");
|
|
}
|
|
}
|
|
|
|
size_t rawID = IID - NUM_SPECIAL_IDS;
|
|
assert(rawID < Identifiers.size() && "invalid identifier ID");
|
|
auto &identRecord = Identifiers[rawID];
|
|
|
|
if (identRecord.Ident.empty()) {
|
|
StringRef text = getIdentifierText(IID);
|
|
identRecord.Ident = getContext().getIdentifier(text);
|
|
}
|
|
return identRecord.Ident;
|
|
}
|
|
|
|
Identifier ModuleFile::getIdentifier(IdentifierID IID) {
|
|
auto name = getDeclBaseName(IID);
|
|
assert(!name.isSpecial());
|
|
return name.getIdentifier();
|
|
}
|
|
|
|
StringRef ModuleFile::getIdentifierText(IdentifierID IID) {
|
|
if (IID == 0)
|
|
return StringRef();
|
|
|
|
assert(IID >= NUM_SPECIAL_IDS);
|
|
|
|
size_t rawID = IID - NUM_SPECIAL_IDS;
|
|
assert(rawID < Identifiers.size() && "invalid identifier ID");
|
|
auto identRecord = Identifiers[rawID];
|
|
|
|
if (!identRecord.Ident.empty())
|
|
return identRecord.Ident.str();
|
|
|
|
return Core->getIdentifierText(IID);
|
|
}
|
|
|
|
Expected<DeclContext *>ModuleFile::getLocalDeclContext(LocalDeclContextID DCID) {
|
|
assert(DCID != 0 && "invalid local DeclContext ID 0");
|
|
auto &declContextOrOffset = LocalDeclContexts[DCID-1];
|
|
|
|
if (declContextOrOffset.isComplete())
|
|
return declContextOrOffset;
|
|
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error = diagnoseFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(declContextOrOffset)))
|
|
return std::move(error);
|
|
llvm::BitstreamEntry entry = fatalIfUnexpected(DeclTypeCursor.advance());
|
|
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return diagnoseFatal();
|
|
|
|
ASTContext &ctx = getContext();
|
|
SmallVector<uint64_t, 64> scratch;
|
|
StringRef blobData;
|
|
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
switch(recordID) {
|
|
case decls_block::ABSTRACT_CLOSURE_EXPR_CONTEXT: {
|
|
TypeID closureTypeID;
|
|
unsigned discriminator = 0;
|
|
bool implicit = false;
|
|
DeclContextID parentID;
|
|
|
|
decls_block::AbstractClosureExprLayout::readRecord(scratch,
|
|
closureTypeID,
|
|
implicit,
|
|
discriminator,
|
|
parentID);
|
|
DeclContext *parent;
|
|
SET_OR_RETURN_ERROR(parent, getDeclContextChecked(parentID));
|
|
|
|
auto type = getType(closureTypeID);
|
|
|
|
declContextOrOffset = new (ctx)
|
|
SerializedAbstractClosureExpr(type, implicit, discriminator, parent);
|
|
break;
|
|
}
|
|
|
|
case decls_block::TOP_LEVEL_CODE_DECL_CONTEXT: {
|
|
DeclContextID parentID;
|
|
decls_block::TopLevelCodeDeclContextLayout::readRecord(scratch,
|
|
parentID);
|
|
DeclContext *parent;
|
|
SET_OR_RETURN_ERROR(parent, getDeclContextChecked(parentID));
|
|
|
|
declContextOrOffset = new (ctx) SerializedTopLevelCodeDeclContext(parent);
|
|
break;
|
|
}
|
|
|
|
case decls_block::PATTERN_BINDING_INITIALIZER_CONTEXT: {
|
|
DeclID bindingID;
|
|
uint32_t bindingIndex;
|
|
decls_block::PatternBindingInitializerLayout::readRecord(scratch,
|
|
bindingID,
|
|
bindingIndex);
|
|
auto decl = getDecl(bindingID);
|
|
PatternBindingDecl *binding = cast<PatternBindingDecl>(decl);
|
|
|
|
if (!declContextOrOffset.isComplete()) {
|
|
declContextOrOffset =
|
|
PatternBindingInitializer::createDeserialized(binding, bindingIndex);
|
|
}
|
|
if (!blobData.empty())
|
|
binding->setInitStringRepresentation(bindingIndex, blobData);
|
|
break;
|
|
}
|
|
|
|
case decls_block::DEFAULT_ARGUMENT_INITIALIZER_CONTEXT: {
|
|
DeclContextID parentID;
|
|
unsigned index = 0;
|
|
decls_block::DefaultArgumentInitializerLayout::readRecord(scratch,
|
|
parentID,
|
|
index);
|
|
DeclContext *parent;
|
|
SET_OR_RETURN_ERROR(parent, getDeclContextChecked(parentID));
|
|
|
|
declContextOrOffset = DefaultArgumentInitializer::create(parent, index);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
fatal(llvm::make_error<InvalidRecordKindError>(recordID,
|
|
"Unknown record ID found when reading local DeclContext."));
|
|
}
|
|
return declContextOrOffset;
|
|
}
|
|
|
|
DeclContext *ModuleFile::getDeclContext(DeclContextID DCID) {
|
|
auto deserialized = getDeclContextChecked(DCID);
|
|
if (!deserialized) {
|
|
fatal(deserialized.takeError());
|
|
}
|
|
return deserialized.get();
|
|
}
|
|
|
|
Expected<DeclContext *> ModuleFile::getDeclContextChecked(DeclContextID DCID) {
|
|
if (!DCID)
|
|
return FileContext;
|
|
|
|
if (std::optional<LocalDeclContextID> contextID =
|
|
DCID.getAsLocalDeclContextID())
|
|
return getLocalDeclContext(contextID.value());
|
|
|
|
auto deserialized = getDeclChecked(DCID.getAsDeclID().value());
|
|
if (!deserialized)
|
|
return deserialized.takeError();
|
|
|
|
auto D = deserialized.get();
|
|
if (auto GTD = dyn_cast<GenericTypeDecl>(D))
|
|
return GTD;
|
|
if (auto ED = dyn_cast<ExtensionDecl>(D))
|
|
return ED;
|
|
if (auto AFD = dyn_cast<AbstractFunctionDecl>(D))
|
|
return AFD;
|
|
if (auto SD = dyn_cast<SubscriptDecl>(D))
|
|
return SD;
|
|
if (auto EED = dyn_cast<EnumElementDecl>(D))
|
|
return EED;
|
|
if (auto MD = dyn_cast<MacroDecl>(D))
|
|
return MD;
|
|
|
|
llvm_unreachable("Unknown Decl : DeclContext kind");
|
|
}
|
|
|
|
ModuleDecl *ModuleFile::getModule(ModuleID MID) {
|
|
if (MID < NUM_SPECIAL_IDS) {
|
|
switch (static_cast<SpecialIdentifierID>(static_cast<uint8_t>(MID))) {
|
|
case BUILTIN_MODULE_ID:
|
|
return getContext().TheBuiltinModule;
|
|
case CURRENT_MODULE_ID:
|
|
return FileContext->getParentModule();
|
|
case OBJC_HEADER_MODULE_ID: {
|
|
auto clangImporter =
|
|
static_cast<ClangImporter *>(getContext().getClangModuleLoader());
|
|
return clangImporter->getImportedHeaderModule();
|
|
}
|
|
case SUBSCRIPT_ID:
|
|
case CONSTRUCTOR_ID:
|
|
case DESTRUCTOR_ID:
|
|
llvm_unreachable("Modules cannot be named with special names");
|
|
case NUM_SPECIAL_IDS:
|
|
llvm_unreachable("implementation detail only");
|
|
}
|
|
}
|
|
return getModule(ImportPath::Module::Builder(getIdentifier(MID)).get(),
|
|
getContext().LangOpts.AllowDeserializingImplementationOnly);
|
|
}
|
|
|
|
ModuleDecl *ModuleFile::getModule(ImportPath::Module name,
|
|
bool allowLoading) {
|
|
if (name.empty() || name.front().Item.empty())
|
|
return getContext().TheBuiltinModule;
|
|
|
|
// FIXME: duplicated from ImportResolver::getModule
|
|
Identifier parentName = FileContext->getParentModule()->getName();
|
|
if (name.size() == 1 &&
|
|
name.front().Item == getContext().getRealModuleName(parentName)) {
|
|
if (!UnderlyingModule && allowLoading) {
|
|
auto importer = getContext().getClangModuleLoader();
|
|
assert(importer && "no way to import shadowed module");
|
|
UnderlyingModule =
|
|
importer->loadModule(SourceLoc(), name.getTopLevelPath());
|
|
}
|
|
|
|
return UnderlyingModule;
|
|
}
|
|
|
|
if (allowLoading)
|
|
return getContext().getModule(name);
|
|
return getContext().getLoadedModule(name);
|
|
}
|
|
|
|
|
|
/// Translate from the Serialization associativity enum values to the AST
|
|
/// strongly-typed enum.
|
|
///
|
|
/// The former is guaranteed to be stable, but may not reflect this version of
|
|
/// the AST.
|
|
static std::optional<swift::Associativity>
|
|
getActualAssociativity(uint8_t assoc) {
|
|
switch (assoc) {
|
|
case serialization::Associativity::LeftAssociative:
|
|
return swift::Associativity::Left;
|
|
case serialization::Associativity::RightAssociative:
|
|
return swift::Associativity::Right;
|
|
case serialization::Associativity::NonAssociative:
|
|
return swift::Associativity::None;
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
static std::optional<swift::StaticSpellingKind>
|
|
getActualStaticSpellingKind(uint8_t raw) {
|
|
switch (serialization::StaticSpellingKind(raw)) {
|
|
case serialization::StaticSpellingKind::None:
|
|
return swift::StaticSpellingKind::None;
|
|
case serialization::StaticSpellingKind::KeywordStatic:
|
|
return swift::StaticSpellingKind::KeywordStatic;
|
|
case serialization::StaticSpellingKind::KeywordClass:
|
|
return swift::StaticSpellingKind::KeywordClass;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static bool isDeclAttrRecord(unsigned ID) {
|
|
using namespace decls_block;
|
|
switch (ID) {
|
|
#define DECL_ATTR(NAME, CLASS, ...) case CLASS##_DECL_ATTR: return true;
|
|
#include "DeclTypeRecordNodes.def"
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
static std::optional<swift::AccessLevel> getActualAccessLevel(uint8_t raw) {
|
|
switch (serialization::AccessLevel(raw)) {
|
|
#define CASE(NAME) \
|
|
case serialization::AccessLevel::NAME: \
|
|
return swift::AccessLevel::NAME;
|
|
CASE(Private)
|
|
CASE(FilePrivate)
|
|
CASE(Internal)
|
|
CASE(Package)
|
|
CASE(Public)
|
|
CASE(Open)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static std::optional<swift::SelfAccessKind>
|
|
getActualSelfAccessKind(uint8_t raw) {
|
|
switch (serialization::SelfAccessKind(raw)) {
|
|
case serialization::SelfAccessKind::NonMutating:
|
|
return swift::SelfAccessKind::NonMutating;
|
|
case serialization::SelfAccessKind::Mutating:
|
|
return swift::SelfAccessKind::Mutating;
|
|
case serialization::SelfAccessKind::LegacyConsuming:
|
|
return swift::SelfAccessKind::LegacyConsuming;
|
|
case serialization::SelfAccessKind::Consuming:
|
|
return swift::SelfAccessKind::Consuming;
|
|
case serialization::SelfAccessKind::Borrowing:
|
|
return swift::SelfAccessKind::Borrowing;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
/// Translate from the serialization VarDeclSpecifier enumerators, which are
|
|
/// guaranteed to be stable, to the AST ones.
|
|
static std::optional<swift::ParamDecl::Specifier>
|
|
getActualParamDeclSpecifier(serialization::ParamDeclSpecifier raw) {
|
|
switch (raw) {
|
|
#define CASE(ID) \
|
|
case serialization::ParamDeclSpecifier::ID: \
|
|
return swift::ParamDecl::Specifier::ID;
|
|
CASE(Default)
|
|
CASE(InOut)
|
|
CASE(Borrowing)
|
|
CASE(Consuming)
|
|
CASE(LegacyShared)
|
|
CASE(LegacyOwned)
|
|
CASE(ImplicitlyCopyableConsuming)
|
|
}
|
|
#undef CASE
|
|
return std::nullopt;
|
|
}
|
|
|
|
static std::optional<swift::OpaqueReadOwnership>
|
|
getActualOpaqueReadOwnership(unsigned rawKind) {
|
|
switch (serialization::OpaqueReadOwnership(rawKind)) {
|
|
#define CASE(KIND) \
|
|
case serialization::OpaqueReadOwnership::KIND: \
|
|
return swift::OpaqueReadOwnership::KIND;
|
|
CASE(Owned)
|
|
CASE(Borrowed)
|
|
CASE(OwnedOrBorrowed)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static std::optional<swift::ReadImplKind>
|
|
getActualReadImplKind(unsigned rawKind) {
|
|
switch (serialization::ReadImplKind(rawKind)) {
|
|
#define CASE(KIND) \
|
|
case serialization::ReadImplKind::KIND: \
|
|
return swift::ReadImplKind::KIND;
|
|
CASE(Stored)
|
|
CASE(Get)
|
|
CASE(Inherited)
|
|
CASE(Address)
|
|
CASE(Read)
|
|
CASE(Read2)
|
|
CASE(Borrow)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static std::optional<swift::WriteImplKind>
|
|
getActualWriteImplKind(unsigned rawKind) {
|
|
switch (serialization::WriteImplKind(rawKind)) {
|
|
#define CASE(KIND) \
|
|
case serialization::WriteImplKind::KIND: \
|
|
return swift::WriteImplKind::KIND;
|
|
CASE(Immutable)
|
|
CASE(Stored)
|
|
CASE(Set)
|
|
CASE(StoredWithObservers)
|
|
CASE(InheritedWithObservers)
|
|
CASE(MutableAddress)
|
|
CASE(Modify)
|
|
CASE(Modify2)
|
|
CASE(Mutate)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static std::optional<swift::ReadWriteImplKind>
|
|
getActualReadWriteImplKind(unsigned rawKind) {
|
|
switch (serialization::ReadWriteImplKind(rawKind)) {
|
|
#define CASE(KIND) \
|
|
case serialization::ReadWriteImplKind::KIND: \
|
|
return swift::ReadWriteImplKind::KIND;
|
|
CASE(Immutable)
|
|
CASE(Stored)
|
|
CASE(MutableAddress)
|
|
CASE(MaterializeToTemporary)
|
|
CASE(Modify)
|
|
CASE(Modify2)
|
|
CASE(StoredWithDidSet)
|
|
CASE(InheritedWithDidSet)
|
|
CASE(Mutate)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
/// Translate from the serialization DifferentiabilityKind enumerators, which
|
|
/// are guaranteed to be stable, to the AST ones.
|
|
static std::optional<swift::AutoDiffDerivativeFunctionKind>
|
|
getActualAutoDiffDerivativeFunctionKind(uint8_t raw) {
|
|
switch (serialization::AutoDiffDerivativeFunctionKind(raw)) {
|
|
#define CASE(ID) \
|
|
case serialization::AutoDiffDerivativeFunctionKind::ID: \
|
|
return {swift::AutoDiffDerivativeFunctionKind::ID};
|
|
CASE(JVP)
|
|
CASE(VJP)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
/// Translate from the Serialization differentiability kind enum values to the
|
|
/// AST strongly-typed enum.
|
|
///
|
|
/// The former is guaranteed to be stable, but may not reflect this version of
|
|
/// the AST.
|
|
static std::optional<swift::DifferentiabilityKind>
|
|
getActualDifferentiabilityKind(uint8_t diffKind) {
|
|
switch (diffKind) {
|
|
#define CASE(THE_DK) \
|
|
case (uint8_t)serialization::DifferentiabilityKind::THE_DK: \
|
|
return swift::DifferentiabilityKind::THE_DK;
|
|
CASE(NonDifferentiable)
|
|
CASE(Forward)
|
|
CASE(Reverse)
|
|
CASE(Normal)
|
|
CASE(Linear)
|
|
#undef CASE
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
static std::optional<swift::MacroRole> getActualMacroRole(uint8_t context) {
|
|
switch (context) {
|
|
#define MACRO_ROLE(Name, Description) \
|
|
case (uint8_t)serialization::MacroRole::Name: \
|
|
return swift::MacroRole::Name;
|
|
#include "swift/Basic/MacroRoles.def"
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static std::optional<swift::MacroIntroducedDeclNameKind>
|
|
getActualMacroIntroducedDeclNameKind(uint8_t context) {
|
|
switch (context) {
|
|
#define CASE(THE_DK) \
|
|
case (uint8_t)serialization::MacroIntroducedDeclNameKind::THE_DK: \
|
|
return swift::MacroIntroducedDeclNameKind::THE_DK;
|
|
CASE(Named)
|
|
CASE(Overloaded)
|
|
CASE(Prefixed)
|
|
CASE(Suffixed)
|
|
CASE(Arbitrary)
|
|
#undef CASE
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
void ModuleFile::configureStorage(AbstractStorageDecl *decl,
|
|
uint8_t rawOpaqueReadOwnership,
|
|
uint8_t rawReadImplKind,
|
|
uint8_t rawWriteImplKind,
|
|
uint8_t rawReadWriteImplKind,
|
|
AccessorRecord &rawIDs) {
|
|
auto opaqueReadOwnership =
|
|
getActualOpaqueReadOwnership(rawOpaqueReadOwnership);
|
|
if (!opaqueReadOwnership)
|
|
return;
|
|
decl->setOpaqueReadOwnership(*opaqueReadOwnership);
|
|
|
|
auto readImpl = getActualReadImplKind(rawReadImplKind);
|
|
if (!readImpl) return;
|
|
|
|
auto writeImpl = getActualWriteImplKind(rawWriteImplKind);
|
|
if (!writeImpl) return;
|
|
|
|
auto readWriteImpl = getActualReadWriteImplKind(rawReadWriteImplKind);
|
|
if (!readWriteImpl) return;
|
|
|
|
auto implInfo = StorageImplInfo(*readImpl, *writeImpl, *readWriteImpl);
|
|
decl->setImplInfo(implInfo);
|
|
|
|
decl->getASTContext().evaluator.cacheOutput(HasStorageRequest{decl}, implInfo.hasStorage());
|
|
|
|
SmallVector<AccessorDecl*, 8> accessors;
|
|
for (DeclID id : rawIDs.IDs) {
|
|
auto accessorOrErr = getDeclChecked(id);
|
|
if (!accessorOrErr) {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(accessorOrErr.takeError());
|
|
diagnoseAndConsumeError(accessorOrErr.takeError());
|
|
continue;
|
|
}
|
|
auto accessor = dyn_cast_or_null<AccessorDecl>(accessorOrErr.get());
|
|
if (!accessor) return;
|
|
accessors.push_back(accessor);
|
|
}
|
|
|
|
if (implInfo.isSimpleStored() && accessors.empty())
|
|
return;
|
|
|
|
// We currently don't serialize these locations.
|
|
SourceLoc beginLoc, endLoc;
|
|
|
|
decl->setAccessors(beginLoc, accessors, endLoc);
|
|
}
|
|
|
|
template <typename T, typename ...Args>
|
|
T *ModuleFile::createDecl(Args &&... args) {
|
|
// Note that this method is not used for all decl kinds.
|
|
static_assert(std::is_base_of<Decl, T>::value, "not a Decl");
|
|
return new (getContext()) T(std::forward<Args>(args)...);
|
|
}
|
|
|
|
template <typename DERIVED>
|
|
static bool attributeChainContains(DeclAttribute *attr) {
|
|
DeclAttributes tempAttrs;
|
|
tempAttrs.setRawAttributeChain(attr);
|
|
static_assert(std::is_trivially_destructible<DeclAttributes>::value,
|
|
"must not try to destroy the attribute chain");
|
|
return tempAttrs.hasAttribute<DERIVED>();
|
|
}
|
|
|
|
Decl *ModuleFile::getDecl(DeclID DID) {
|
|
Expected<Decl *> deserialized = getDeclChecked(DID);
|
|
if (!deserialized) {
|
|
fatal(deserialized.takeError());
|
|
}
|
|
return deserialized.get();
|
|
}
|
|
|
|
/// Used to split up methods that would otherwise live in ModuleFile.
|
|
namespace swift {
|
|
class DeclDeserializer {
|
|
template <typename T>
|
|
using Serialized = ModuleFile::Serialized<T>;
|
|
using TypeID = serialization::TypeID;
|
|
|
|
ModuleFile &MF;
|
|
ASTContext &ctx;
|
|
Serialized<Decl *> &declOrOffset;
|
|
|
|
bool IsInvalid = false;
|
|
|
|
DeclAttribute *DAttrs = nullptr;
|
|
DeclAttribute **AttrsNext = &DAttrs;
|
|
SmallVector<serialization::BitOffset> customAttrOffsets;
|
|
|
|
Identifier privateDiscriminator;
|
|
unsigned localDiscriminator = ValueDecl::InvalidDiscriminator;
|
|
StringRef filenameForPrivate;
|
|
|
|
// Auxiliary map for deserializing `@differentiable` attributes.
|
|
llvm::DenseMap<DifferentiableAttr *, IndexSubset *> diffAttrParamIndicesMap;
|
|
|
|
/// State for resolving the declaration in an ABIAttr.
|
|
std::optional<std::pair<ABIAttr *, DeclID>> unresolvedABIAttr;
|
|
/// State for setting up an ABIAttr's counterpart relationship.
|
|
DeclID ABIDeclCounterpartID = 0;
|
|
|
|
void AddAttribute(DeclAttribute *Attr) {
|
|
// Advance the linked list.
|
|
// This isn't just using DeclAttributes because that would result in the
|
|
// attributes getting reversed.
|
|
// FIXME: If we reverse them at serialization time we could get rid of this.
|
|
*AttrsNext = Attr;
|
|
AttrsNext = Attr->getMutableNext();
|
|
};
|
|
|
|
void handleInherited(llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
|
|
ArrayRef<uint64_t> rawInheritedIDs) {
|
|
SmallVector<InheritedEntry, 2> inheritedTypes;
|
|
for (auto rawID : rawInheritedIDs) {
|
|
// The first low bit indicates "~" (suppression).
|
|
bool isSuppressed = rawID & 0x01;
|
|
rawID = rawID >> 1;
|
|
|
|
// The next bits are the protocol conformance options.
|
|
// Update the mask below whenever this changes.
|
|
static_assert(NumProtocolConformanceOptions == 6);
|
|
ProtocolConformanceOptions options(rawID & 0x3F, /*global actor*/nullptr);
|
|
rawID = rawID >> NumProtocolConformanceOptions;
|
|
|
|
TypeID typeID = rawID;
|
|
auto maybeType = MF.getTypeChecked(typeID);
|
|
if (!maybeType) {
|
|
MF.diagnoseAndConsumeError(maybeType.takeError());
|
|
continue;
|
|
}
|
|
inheritedTypes.push_back(InheritedEntry(
|
|
TypeLoc::withoutLoc(maybeType.get()), options, isSuppressed));
|
|
}
|
|
|
|
auto inherited = ctx.AllocateCopy(inheritedTypes);
|
|
if (auto *typeDecl = decl.dyn_cast<TypeDecl *>())
|
|
typeDecl->setInherited(inherited);
|
|
else
|
|
cast<ExtensionDecl *>(decl)->setInherited(inherited);
|
|
}
|
|
|
|
llvm::Error finishRecursiveAttrs();
|
|
|
|
public:
|
|
DeclDeserializer(ModuleFile &MF, Serialized<Decl *> &declOrOffset)
|
|
: MF(MF), ctx(MF.getContext()), declOrOffset(declOrOffset) {}
|
|
|
|
~DeclDeserializer() {
|
|
if (!declOrOffset.isComplete()) {
|
|
// We failed to deserialize this declaration.
|
|
return;
|
|
}
|
|
|
|
Decl *decl = declOrOffset.get();
|
|
if (!decl)
|
|
return;
|
|
|
|
if (IsInvalid) {
|
|
decl->setInvalidBit();
|
|
|
|
auto diagId = MF.allowCompilerErrors()
|
|
? diag::serialization_allowing_invalid_decl
|
|
: diag::serialization_invalid_decl;
|
|
ctx.Diags.diagnose(SourceLoc(), diagId, decl, MF.getAssociatedModule());
|
|
}
|
|
|
|
if (DAttrs) {
|
|
decl->getAttrs().setRawAttributeChain(DAttrs);
|
|
// Wire up the attached decl.
|
|
for (auto *attr : decl->getAttrs())
|
|
attr->attachToDecl(decl);
|
|
|
|
// Wire up the indices for @differentiable.
|
|
for (auto *attr : decl->getAttrs().getAttributes<DifferentiableAttr>())
|
|
attr->setParameterIndices(diffAttrParamIndicesMap[attr]);
|
|
}
|
|
|
|
if (auto value = dyn_cast<ValueDecl>(decl)) {
|
|
if (!privateDiscriminator.empty())
|
|
MF.PrivateDiscriminatorsByValue[value] = privateDiscriminator;
|
|
|
|
if (localDiscriminator != ValueDecl::InvalidDiscriminator)
|
|
value->setLocalDiscriminator(localDiscriminator);
|
|
|
|
if (!filenameForPrivate.empty())
|
|
MF.FilenamesForPrivateValues[value] = filenameForPrivate;
|
|
}
|
|
}
|
|
|
|
/// Deserializes records common to all decls from \c MF.DeclTypesCursor (ie.
|
|
/// the invalid flag, attributes, and discriminators)
|
|
///
|
|
/// Reads all attributes except for custom attributes that are skipped and
|
|
/// their offsets added to \c customAttrOffsets.
|
|
llvm::Error deserializeDeclCommon();
|
|
|
|
/// Deserializes the custom attributes from \c MF.DeclTypesCursor, using the
|
|
/// offsets in \c customAttrOffsets.
|
|
llvm::Error deserializeCustomAttrs();
|
|
|
|
DeclNameRef deserializeDeclNameRefIfPresent() {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 64> scratch;
|
|
StringRef blobData;
|
|
|
|
BCOffsetRAII restoreOffset(MF.DeclTypeCursor);
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance());
|
|
|
|
unsigned recordID = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
|
|
if (recordID != DECL_NAME_REF)
|
|
// This is normal--it just means there isn't a DeclNameRef here.
|
|
return { DeclNameRef() };
|
|
|
|
bool isCompoundName;
|
|
bool hasModuleSelector;
|
|
ArrayRef<uint64_t> rawPieceIDs;
|
|
|
|
DeclNameRefLayout::readRecord(scratch, isCompoundName, hasModuleSelector,
|
|
rawPieceIDs);
|
|
restoreOffset.cancel();
|
|
|
|
Identifier moduleSelector;
|
|
DeclBaseName baseName;
|
|
|
|
unsigned restIndex = 0;
|
|
|
|
ASSERT(rawPieceIDs.size() > 0);
|
|
if (hasModuleSelector) {
|
|
moduleSelector = MF.getIdentifier(rawPieceIDs[restIndex]);
|
|
restIndex++;
|
|
}
|
|
|
|
ASSERT(rawPieceIDs.size() > restIndex);
|
|
baseName = MF.getDeclBaseName(rawPieceIDs[restIndex]);
|
|
restIndex++;
|
|
|
|
if (isCompoundName) {
|
|
SmallVector<Identifier, 8> argLabels;
|
|
for (auto rawArgLabel : rawPieceIDs.drop_front(restIndex))
|
|
argLabels.push_back(MF.getIdentifier(rawArgLabel));
|
|
|
|
return DeclNameRef(ctx, moduleSelector, baseName, argLabels);
|
|
}
|
|
|
|
ASSERT(rawPieceIDs.size() == restIndex);
|
|
return DeclNameRef(ctx, moduleSelector, baseName);
|
|
}
|
|
|
|
Expected<Decl *> getDeclCheckedImpl(
|
|
llvm::function_ref<bool(DeclAttributes)> matchAttributes = nullptr);
|
|
|
|
Expected<Decl *> deserializeTypeAlias(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
TypeID underlyingTypeID, interfaceTypeID;
|
|
bool isImplicit;
|
|
GenericSignatureID genericSigID;
|
|
uint8_t rawAccessLevel;
|
|
ArrayRef<uint64_t> dependencyIDs;
|
|
|
|
decls_block::TypeAliasLayout::readRecord(scratch, nameID, contextID,
|
|
underlyingTypeID, interfaceTypeID,
|
|
isImplicit, genericSigID,
|
|
rawAccessLevel, dependencyIDs);
|
|
|
|
Identifier name = MF.getIdentifier(nameID);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
for (TypeID dependencyID : dependencyIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()));
|
|
}
|
|
}
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(DC));
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto alias = MF.createDecl<TypeAliasDecl>(SourceLoc(), SourceLoc(), name,
|
|
SourceLoc(), genericParams, DC);
|
|
declOrOffset = alias;
|
|
|
|
auto genericSig = MF.getGenericSignature(genericSigID);
|
|
alias->setGenericSignature(genericSig);
|
|
|
|
auto underlyingOrErr = MF.getTypeChecked(underlyingTypeID);
|
|
if (!underlyingOrErr)
|
|
return underlyingOrErr.takeError();
|
|
alias->setUnderlyingType(underlyingOrErr.get());
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
alias->setAccess(*accessLevel);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
if (isImplicit)
|
|
alias->setImplicit();
|
|
|
|
return alias;
|
|
}
|
|
|
|
Expected<Decl *>
|
|
deserializeGenericTypeParamDecl(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
bool isImplicit;
|
|
bool isOpaqueType;
|
|
TypeID interfaceTypeID;
|
|
|
|
decls_block::GenericTypeParamDeclLayout::readRecord(
|
|
scratch, nameID, isImplicit, isOpaqueType, interfaceTypeID);
|
|
|
|
auto interfaceTy = MF.getTypeChecked(interfaceTypeID);
|
|
if (!interfaceTy)
|
|
return interfaceTy.takeError();
|
|
|
|
auto paramTy = interfaceTy.get()->castTo<GenericTypeParamType>();
|
|
|
|
// Always create GenericTypeParamDecls in the associated file; the real
|
|
// context will reparent them.
|
|
auto *DC = MF.getFile();
|
|
auto *genericParam = GenericTypeParamDecl::createDeserialized(
|
|
DC, MF.getIdentifier(nameID), paramTy->getDepth(), paramTy->getIndex(),
|
|
paramTy->getParamKind(), isOpaqueType);
|
|
declOrOffset = genericParam;
|
|
|
|
if (isImplicit)
|
|
genericParam->setImplicit();
|
|
|
|
// If we're dealing with a value generic, the parameter type already
|
|
// serializes the value type. Inform the request evaluator that we don't
|
|
// need to recompute this value for the param decl.
|
|
if (paramTy->isValue()) {
|
|
ctx.evaluator.cacheOutput(
|
|
GenericTypeParamDeclGetValueTypeRequest{genericParam},
|
|
paramTy->getValueType());
|
|
}
|
|
|
|
return genericParam;
|
|
}
|
|
|
|
Expected<Decl *>
|
|
deserializeAssociatedTypeDecl(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
TypeID defaultDefinitionID;
|
|
bool isImplicit;
|
|
ArrayRef<uint64_t> rawOverriddenIDs;
|
|
|
|
decls_block::AssociatedTypeDeclLayout::readRecord(scratch, nameID,
|
|
contextID,
|
|
defaultDefinitionID,
|
|
isImplicit,
|
|
rawOverriddenIDs);
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
// The where-clause information is pushed up into the protocol
|
|
// (specifically, into its requirement signature) and
|
|
// serialized/deserialized there, so the actual Decl doesn't need to store
|
|
// it.
|
|
TrailingWhereClause *trailingWhere = nullptr;
|
|
auto *assocType = AssociatedTypeDecl::createDeserialized(
|
|
ctx, DC, SourceLoc(), MF.getIdentifier(nameID), SourceLoc(),
|
|
trailingWhere, &MF, defaultDefinitionID);
|
|
declOrOffset = assocType;
|
|
|
|
assert(!assocType->getDeclaredInterfaceType()->hasError() &&
|
|
"erroneous associated type");
|
|
|
|
AccessLevel parentAccess = cast<ProtocolDecl>(DC)->getFormalAccess();
|
|
assocType->setAccess(std::max(parentAccess, AccessLevel::Internal));
|
|
if (isImplicit)
|
|
assocType->setImplicit();
|
|
|
|
// Overridden associated types.
|
|
SmallVector<ValueDecl *, 2> overriddenAssocTypes;
|
|
for (auto overriddenID : rawOverriddenIDs) {
|
|
if (auto overriddenAssocType =
|
|
dyn_cast_or_null<AssociatedTypeDecl>(MF.getDecl(overriddenID))) {
|
|
overriddenAssocTypes.push_back(overriddenAssocType);
|
|
}
|
|
}
|
|
assocType->setOverriddenDecls(overriddenAssocTypes);
|
|
|
|
return assocType;
|
|
}
|
|
|
|
Expected<Decl *> deserializeStruct(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
bool isImplicit;
|
|
bool isObjC;
|
|
GenericSignatureID genericSigID;
|
|
uint8_t rawAccessLevel;
|
|
unsigned numConformances, numInheritedTypes;
|
|
ArrayRef<uint64_t> rawIDs;
|
|
|
|
decls_block::StructLayout::readRecord(scratch, nameID, contextID,
|
|
isImplicit, isObjC, genericSigID,
|
|
rawAccessLevel,
|
|
numConformances, numInheritedTypes,
|
|
rawIDs);
|
|
|
|
Identifier name = MF.getIdentifier(nameID);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
auto conformanceIDs = rawIDs.slice(0, numConformances);
|
|
rawIDs = rawIDs.slice(numConformances);
|
|
auto inheritedIDs = rawIDs.slice(0, numInheritedTypes);
|
|
auto dependencyIDs = rawIDs.slice(numInheritedTypes);
|
|
|
|
for (TypeID dependencyID : dependencyIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()));
|
|
}
|
|
}
|
|
|
|
auto DCOrError = MF.getDeclContextChecked(contextID);
|
|
if (!DCOrError)
|
|
return DCOrError.takeError();
|
|
auto DC = DCOrError.get();
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(DC));
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto theStruct = MF.createDecl<StructDecl>(SourceLoc(), name, SourceLoc(),
|
|
ArrayRef<InheritedEntry>(),
|
|
genericParams, DC);
|
|
declOrOffset = theStruct;
|
|
|
|
// Read the generic environment.
|
|
theStruct->setGenericSignature(MF.getGenericSignature(genericSigID));
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
theStruct->setAccess(*accessLevel);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
theStruct->setAddedImplicitInitializers();
|
|
if (isImplicit)
|
|
theStruct->setImplicit();
|
|
theStruct->setIsObjC(isObjC);
|
|
|
|
handleInherited(theStruct, inheritedIDs);
|
|
|
|
theStruct->setMemberLoader(&MF, MF.DeclTypeCursor.GetCurrentBitNo());
|
|
skipRecord(MF.DeclTypeCursor, decls_block::MEMBERS);
|
|
theStruct->setConformanceLoader(
|
|
&MF, MF.createLazyConformanceLoaderToken(conformanceIDs));
|
|
|
|
return theStruct;
|
|
}
|
|
|
|
Expected<Decl *> deserializeConstructor(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
DeclContextID contextID;
|
|
bool isIUO, isFailable;
|
|
bool isImplicit, isObjC, hasStubImplementation, throws, async;
|
|
TypeID thrownTypeID;
|
|
GenericSignatureID genericSigID;
|
|
uint8_t storedInitKind, rawAccessLevel;
|
|
DeclID overriddenID;
|
|
bool overriddenAffectsABI, needsNewTableEntry, firstTimeRequired;
|
|
unsigned numArgNames;
|
|
ArrayRef<uint64_t> argNameAndDependencyIDs;
|
|
|
|
decls_block::ConstructorLayout::readRecord(scratch, contextID,
|
|
isFailable, isIUO, isImplicit,
|
|
isObjC, hasStubImplementation,
|
|
async, throws, thrownTypeID,
|
|
storedInitKind,
|
|
genericSigID,
|
|
overriddenID,
|
|
overriddenAffectsABI,
|
|
rawAccessLevel,
|
|
needsNewTableEntry,
|
|
firstTimeRequired,
|
|
numArgNames,
|
|
argNameAndDependencyIDs);
|
|
|
|
// Resolve the name ids.
|
|
SmallVector<Identifier, 2> argNames;
|
|
for (auto argNameID : argNameAndDependencyIDs.slice(0, numArgNames))
|
|
argNames.push_back(MF.getIdentifier(argNameID));
|
|
DeclName name(ctx, DeclBaseName::createConstructor(), argNames);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
std::optional<swift::CtorInitializerKind> initKind =
|
|
getActualCtorInitializerKind(storedInitKind);
|
|
|
|
DeclDeserializationError::Flags errorFlags;
|
|
unsigned numTableEntries = 0;
|
|
if (initKind == CtorInitializerKind::Designated)
|
|
errorFlags |= DeclDeserializationError::DesignatedInitializer;
|
|
if (needsNewTableEntry) {
|
|
numTableEntries = 1;
|
|
DeclAttributes attrs;
|
|
attrs.setRawAttributeChain(DAttrs);
|
|
}
|
|
|
|
Expected<Decl *> overriddenOrError = MF.getDeclChecked(overriddenID);
|
|
Decl *overridden;
|
|
if (overriddenOrError) {
|
|
overridden = overriddenOrError.get();
|
|
} else if (overriddenOrError.errorIsA<FatalDeserializationError>()) {
|
|
// Pass through fatal deserialization errors.
|
|
return overriddenOrError.takeError();
|
|
} else if (MF.allowCompilerErrors()) {
|
|
// Drop overriding relationship when allowing errors.
|
|
MF.diagnoseAndConsumeError(overriddenOrError.takeError());
|
|
overridden = nullptr;
|
|
} else {
|
|
MF.diagnoseAndConsumeError(overriddenOrError.takeError());
|
|
if (overriddenAffectsABI || !ctx.LangOpts.EnableDeserializationRecovery) {
|
|
return llvm::make_error<OverrideError>(name, errorFlags,
|
|
numTableEntries);
|
|
}
|
|
|
|
overridden = nullptr;
|
|
}
|
|
|
|
for (auto dependencyID : argNameAndDependencyIDs.slice(numArgNames)) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()),
|
|
errorFlags, numTableEntries);
|
|
}
|
|
}
|
|
|
|
DeclContext *parent;
|
|
SET_OR_RETURN_ERROR(parent, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(parent));
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto thrownTypeOrError = MF.getTypeChecked(thrownTypeID);
|
|
if (!thrownTypeOrError)
|
|
return thrownTypeOrError.takeError();
|
|
const auto thrownType = thrownTypeOrError.get();
|
|
|
|
auto ctor = MF.createDecl<ConstructorDecl>(name, SourceLoc(), isFailable,
|
|
/*FailabilityLoc=*/SourceLoc(),
|
|
/*Async=*/async,
|
|
/*AsyncLoc=*/SourceLoc(),
|
|
/*Throws=*/throws,
|
|
/*ThrowsLoc=*/SourceLoc(),
|
|
TypeLoc::withoutLoc(thrownType),
|
|
/*BodyParams=*/nullptr,
|
|
genericParams, parent);
|
|
declOrOffset = ctor;
|
|
|
|
ctor->setGenericSignature(MF.getGenericSignature(genericSigID));
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
ctor->setAccess(*accessLevel);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
ParameterList *bodyParams;
|
|
SET_OR_RETURN_ERROR(bodyParams, MF.readParameterList());
|
|
assert(bodyParams && "missing parameters for constructor");
|
|
ctor->setParameters(bodyParams);
|
|
|
|
SmallVector<LifetimeDependenceInfo, 1> lifetimeDependencies;
|
|
while (auto info = MF.maybeReadLifetimeDependence()) {
|
|
assert(info.has_value());
|
|
lifetimeDependencies.push_back(*info);
|
|
}
|
|
|
|
ctx.evaluator.cacheOutput(LifetimeDependenceInfoRequest{ctor},
|
|
lifetimeDependencies.empty()
|
|
? ArrayRef<LifetimeDependenceInfo>()
|
|
: ctx.AllocateCopy(lifetimeDependencies));
|
|
|
|
if (auto errorConvention = MF.maybeReadForeignErrorConvention())
|
|
ctor->setForeignErrorConvention(*errorConvention);
|
|
if (auto asyncConvention = MF.maybeReadForeignAsyncConvention())
|
|
ctor->setForeignAsyncConvention(*asyncConvention);
|
|
|
|
if (auto bodyText = MF.maybeReadInlinableBodyText())
|
|
ctor->setBodyStringRepresentation(*bodyText);
|
|
|
|
if (isImplicit)
|
|
ctor->setImplicit();
|
|
ctor->setIsObjC(isObjC);
|
|
if (hasStubImplementation)
|
|
ctor->setStubImplementation(true);
|
|
if (initKind.has_value())
|
|
ctx.evaluator.cacheOutput(InitKindRequest{ctor},
|
|
std::move(initKind.value()));
|
|
|
|
ctor->setOverriddenDecl(cast_or_null<ConstructorDecl>(overridden));
|
|
if (auto *overridden = ctor->getOverriddenDecl()) {
|
|
if (!attributeChainContains<RequiredAttr>(DAttrs) ||
|
|
!overridden->isRequired()) {
|
|
// FIXME: why is a convenience init considered overridden when the
|
|
// overriding init can't be marked overriding in source?
|
|
if (!overridden->isConvenienceInit())
|
|
AddAttribute(new (ctx) OverrideAttr(SourceLoc()));
|
|
}
|
|
}
|
|
|
|
ctor->setImplicitlyUnwrappedOptional(isIUO);
|
|
|
|
return ctor;
|
|
}
|
|
|
|
Expected<Decl *> deserializeVar(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
bool isImplicit, isObjC, isStatic;
|
|
uint8_t rawIntroducer;
|
|
bool isGetterMutating, isSetterMutating;
|
|
bool isTopLevelGlobal;
|
|
DeclID lazyStorageID;
|
|
unsigned numAccessors, numBackingProperties;
|
|
uint8_t readImpl, writeImpl, readWriteImpl, opaqueReadOwnership;
|
|
uint8_t rawAccessLevel, rawSetterAccessLevel;
|
|
TypeID interfaceTypeID;
|
|
bool isIUO;
|
|
ModuleFile::AccessorRecord accessors;
|
|
DeclID overriddenID, opaqueReturnTypeID;
|
|
unsigned numVTableEntries;
|
|
ArrayRef<uint64_t> arrayFieldIDs;
|
|
|
|
decls_block::VarLayout::readRecord(scratch, nameID, contextID,
|
|
isImplicit, isObjC, isStatic, rawIntroducer,
|
|
isGetterMutating, isSetterMutating,
|
|
isTopLevelGlobal,
|
|
lazyStorageID,
|
|
opaqueReadOwnership,
|
|
readImpl, writeImpl, readWriteImpl,
|
|
numAccessors,
|
|
interfaceTypeID,
|
|
isIUO,
|
|
overriddenID,
|
|
rawAccessLevel, rawSetterAccessLevel,
|
|
opaqueReturnTypeID,
|
|
numBackingProperties,
|
|
numVTableEntries,
|
|
arrayFieldIDs);
|
|
|
|
Identifier name = MF.getIdentifier(nameID);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
auto getErrorFlags = [&]() {
|
|
// Stored properties in classes still impact class object layout because
|
|
// their offset is computed and stored in the field offset vector.
|
|
DeclDeserializationError::Flags errorFlags;
|
|
|
|
if (!isStatic) {
|
|
auto actualReadImpl = getActualReadImplKind(readImpl);
|
|
if (actualReadImpl && *actualReadImpl == ReadImplKind::Stored) {
|
|
errorFlags |= DeclDeserializationError::Flag::NeedsFieldOffsetVectorEntry;
|
|
}
|
|
}
|
|
|
|
return errorFlags;
|
|
};
|
|
|
|
Expected<Decl *> overridden = MF.getDeclChecked(overriddenID);
|
|
if (!overridden) {
|
|
// Pass through deserialization errors.
|
|
if (overridden.errorIsA<FatalDeserializationError>())
|
|
return overridden.takeError();
|
|
|
|
MF.diagnoseAndConsumeError(overridden.takeError());
|
|
|
|
return llvm::make_error<OverrideError>(
|
|
name, getErrorFlags(), numVTableEntries);
|
|
}
|
|
|
|
// Extract the accessor IDs.
|
|
for (DeclID accessorID : arrayFieldIDs.slice(0, numAccessors)) {
|
|
accessors.IDs.push_back(accessorID);
|
|
}
|
|
arrayFieldIDs = arrayFieldIDs.slice(numAccessors);
|
|
|
|
// Extract the backing property IDs.
|
|
auto backingPropertyIDs = arrayFieldIDs.slice(0, numBackingProperties);
|
|
arrayFieldIDs = arrayFieldIDs.slice(numBackingProperties);
|
|
|
|
for (TypeID dependencyID : arrayFieldIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()),
|
|
getErrorFlags(), numVTableEntries);
|
|
}
|
|
}
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto introducer = getActualVarDeclIntroducer(
|
|
(serialization::VarDeclIntroducer) rawIntroducer);
|
|
if (!introducer)
|
|
return MF.diagnoseFatal();
|
|
|
|
auto var = MF.createDecl<VarDecl>(/*IsStatic*/ isStatic, *introducer,
|
|
SourceLoc(), name, DC);
|
|
var->setIsGetterMutating(isGetterMutating);
|
|
var->setIsSetterMutating(isSetterMutating);
|
|
declOrOffset = var;
|
|
|
|
MF.configureStorage(var, opaqueReadOwnership,
|
|
readImpl, writeImpl, readWriteImpl, accessors);
|
|
|
|
auto interfaceTypeOrError = MF.getTypeChecked(interfaceTypeID);
|
|
if (!interfaceTypeOrError)
|
|
return interfaceTypeOrError.takeError();
|
|
Type interfaceType = interfaceTypeOrError.get();
|
|
var->setInterfaceType(interfaceType);
|
|
var->setImplicitlyUnwrappedOptional(isIUO);
|
|
|
|
if (auto referenceStorage = interfaceType->getAs<ReferenceStorageType>())
|
|
AddAttribute(
|
|
new (ctx) ReferenceOwnershipAttr(referenceStorage->getOwnership()));
|
|
|
|
auto accessLevel = getActualAccessLevel(rawAccessLevel);
|
|
if (!accessLevel)
|
|
return MF.diagnoseFatal();
|
|
|
|
var->setAccess(*accessLevel);
|
|
|
|
if (var->isSettable(nullptr)) {
|
|
auto setterAccess = getActualAccessLevel(rawSetterAccessLevel);
|
|
if (!setterAccess)
|
|
return MF.diagnoseFatal();
|
|
var->setSetterAccess(*setterAccess);
|
|
|
|
// If we have a less-accessible setter, honor that by adding the
|
|
// setter access attribute.
|
|
if (*setterAccess < *accessLevel) {
|
|
AddAttribute(
|
|
new (ctx) SetterAccessAttr(SourceLoc(), SourceLoc(),
|
|
*setterAccess, /*implicit*/true));
|
|
}
|
|
}
|
|
|
|
if (isImplicit)
|
|
var->setImplicit();
|
|
var->setIsObjC(isObjC);
|
|
|
|
var->setOverriddenDecl(cast_or_null<VarDecl>(overridden.get()));
|
|
if (var->getOverriddenDecl())
|
|
AddAttribute(new (ctx) OverrideAttr(SourceLoc()));
|
|
|
|
// Add the @_hasStorage attribute if this var has storage.
|
|
// (Unless it's an ABI-only decl--they shouldn't have a HasStorageAttr.)
|
|
if (var->hasStorage() && ABIDeclCounterpartID == 0)
|
|
AddAttribute(new (ctx) HasStorageAttr(/*isImplicit:*/true));
|
|
|
|
{
|
|
OpaqueTypeDecl *opaqueDecl = nullptr;
|
|
if (opaqueReturnTypeID) {
|
|
auto opaqueReturnType = MF.getDeclChecked(opaqueReturnTypeID);
|
|
if (!opaqueReturnType)
|
|
return opaqueReturnType.takeError();
|
|
|
|
opaqueDecl = cast<OpaqueTypeDecl>(opaqueReturnType.get());
|
|
}
|
|
ctx.evaluator.cacheOutput(OpaqueResultTypeRequest{var},
|
|
std::move(opaqueDecl));
|
|
}
|
|
|
|
// If this is a lazy property, record its backing storage.
|
|
if (lazyStorageID) {
|
|
auto lazyStorageDecl = MF.getDeclChecked(lazyStorageID);
|
|
if (!lazyStorageDecl)
|
|
return lazyStorageDecl.takeError();
|
|
|
|
VarDecl *storage = cast<VarDecl>(lazyStorageDecl.get());
|
|
ctx.evaluator.cacheOutput(
|
|
LazyStoragePropertyRequest{var}, std::move(storage));
|
|
storage->setLazyStorageFor(var);
|
|
}
|
|
|
|
var->setTopLevelGlobal(isTopLevelGlobal);
|
|
|
|
// If there are any backing properties, record them.
|
|
if (numBackingProperties > 0) {
|
|
auto backingDecl = MF.getDeclChecked(backingPropertyIDs[0]);
|
|
if (!backingDecl) {
|
|
// Pass through deserialization errors.
|
|
if (backingDecl.errorIsA<FatalDeserializationError>())
|
|
return backingDecl.takeError();
|
|
|
|
// FIXME: This is actually wrong. We can't just drop stored properties
|
|
// willy-nilly if the struct is @frozen.
|
|
MF.diagnoseAndConsumeError(backingDecl.takeError());
|
|
return var;
|
|
}
|
|
|
|
VarDecl *backingVar = cast<VarDecl>(backingDecl.get());
|
|
VarDecl *projectionVar = nullptr;
|
|
if (numBackingProperties > 1) {
|
|
projectionVar = cast<VarDecl>(MF.getDecl(backingPropertyIDs[1]));
|
|
}
|
|
|
|
PropertyWrapperAuxiliaryVariables vars(backingVar, projectionVar);
|
|
ctx.evaluator.cacheOutput(
|
|
PropertyWrapperAuxiliaryVariablesRequest{var}, std::move(vars));
|
|
ctx.evaluator.cacheOutput(
|
|
PropertyWrapperInitializerInfoRequest{var},
|
|
PropertyWrapperInitializerInfo());
|
|
ctx.evaluator.cacheOutput(
|
|
PropertyWrapperBackingPropertyTypeRequest{var},
|
|
backingVar->getInterfaceType());
|
|
backingVar->setOriginalWrappedProperty(var);
|
|
|
|
if (projectionVar)
|
|
projectionVar->setOriginalWrappedProperty(var);
|
|
}
|
|
|
|
return var;
|
|
}
|
|
|
|
Expected<Decl *> deserializeParam(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID argNameID, paramNameID;
|
|
DeclContextID contextID;
|
|
unsigned rawSpecifier;
|
|
TypeID interfaceTypeID;
|
|
bool isIUO;
|
|
bool isVariadic;
|
|
bool isAutoClosure;
|
|
bool isIsolated;
|
|
bool isCompileTimeLiteral, isConstValue;
|
|
bool isSending;
|
|
bool isAddressable;
|
|
uint8_t rawDefaultArg;
|
|
TypeID defaultExprType;
|
|
uint8_t rawDefaultArgIsolation;
|
|
TypeID globalActorTypeID;
|
|
|
|
decls_block::ParamLayout::readRecord(scratch, argNameID, paramNameID,
|
|
contextID, rawSpecifier,
|
|
interfaceTypeID, isIUO, isVariadic,
|
|
isAutoClosure, isIsolated,
|
|
isCompileTimeLiteral,
|
|
isConstValue,
|
|
isSending,
|
|
isAddressable,
|
|
rawDefaultArg,
|
|
defaultExprType,
|
|
rawDefaultArgIsolation,
|
|
globalActorTypeID);
|
|
|
|
auto argName = MF.getIdentifier(argNameID);
|
|
auto paramName = MF.getIdentifier(paramNameID);
|
|
PrettySupplementalDeclNameTrace trace(paramName);
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto specifier = getActualParamDeclSpecifier(
|
|
(serialization::ParamDeclSpecifier)rawSpecifier);
|
|
if (!specifier)
|
|
return MF.diagnoseFatal();
|
|
|
|
auto param = MF.createDecl<ParamDecl>(SourceLoc(), SourceLoc(), argName,
|
|
SourceLoc(), paramName, DC);
|
|
param->setSpecifier(*specifier);
|
|
|
|
declOrOffset = param;
|
|
|
|
Type paramTy;
|
|
SET_OR_RETURN_ERROR(paramTy, MF.getTypeChecked(interfaceTypeID));
|
|
|
|
if (paramTy->hasError() && !MF.allowCompilerErrors()) {
|
|
// FIXME: This should never happen, because we don't serialize
|
|
// error types.
|
|
DC->printContext(llvm::errs());
|
|
paramTy->dump(llvm::errs());
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
param->setInterfaceType(paramTy);
|
|
param->setImplicitlyUnwrappedOptional(isIUO);
|
|
param->setVariadic(isVariadic);
|
|
param->setAutoClosure(isAutoClosure);
|
|
param->setIsolated(isIsolated);
|
|
param->setCompileTimeLiteral(isCompileTimeLiteral);
|
|
param->setConstValue(isConstValue);
|
|
param->setSending(isSending);
|
|
param->setAddressable(isAddressable);
|
|
|
|
// Decode the default argument kind.
|
|
// FIXME: Default argument expression, if available.
|
|
if (auto defaultArg = getActualDefaultArgKind(rawDefaultArg)) {
|
|
param->setDefaultArgumentKind(*defaultArg);
|
|
|
|
Type exprType;
|
|
SET_OR_RETURN_ERROR(exprType, MF.getTypeChecked(defaultExprType));
|
|
if (exprType)
|
|
param->setDefaultExprType(exprType);
|
|
|
|
auto isoKind = *getActualActorIsolationKind(rawDefaultArgIsolation);
|
|
auto globalActor = MF.getType(globalActorTypeID);
|
|
ActorIsolation isolation;
|
|
switch (isoKind) {
|
|
case ActorIsolation::Unspecified:
|
|
case ActorIsolation::Nonisolated:
|
|
case ActorIsolation::NonisolatedUnsafe:
|
|
isolation = ActorIsolation::forUnspecified();
|
|
break;
|
|
|
|
case ActorIsolation::CallerIsolationInheriting:
|
|
isolation = ActorIsolation::forCallerIsolationInheriting();
|
|
break;
|
|
|
|
case ActorIsolation::Erased:
|
|
isolation = ActorIsolation::forErased();
|
|
break;
|
|
|
|
case ActorIsolation::GlobalActor:
|
|
// 'unsafe' or 'preconcurrency' doesn't mean anything for isolated
|
|
// default arguments.
|
|
isolation = ActorIsolation::forGlobalActor(globalActor);
|
|
break;
|
|
|
|
case ActorIsolation::ActorInstance:
|
|
llvm_unreachable("default arg cannot be actor instance isolated");
|
|
}
|
|
|
|
ctx.evaluator.cacheOutput(
|
|
DefaultInitializerIsolation{param},
|
|
std::move(isolation));
|
|
|
|
if (!blobData.empty())
|
|
param->setDefaultValueStringRepresentation(blobData);
|
|
}
|
|
return param;
|
|
}
|
|
|
|
Expected<Decl *> deserializeAnyFunc(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData,
|
|
bool isAccessor) {
|
|
DeclContextID contextID;
|
|
bool isImplicit;
|
|
bool isStatic;
|
|
uint8_t rawStaticSpelling, rawAccessLevel, rawMutModifier;
|
|
uint8_t rawAccessorKind;
|
|
bool isObjC, hasForcedStaticDispatch, async, throws;
|
|
TypeID thrownTypeID;
|
|
unsigned numNameComponentsBiased;
|
|
GenericSignatureID genericSigID;
|
|
TypeID resultInterfaceTypeID;
|
|
bool isIUO;
|
|
DeclID associatedDeclID;
|
|
DeclID overriddenID;
|
|
DeclID accessorStorageDeclID;
|
|
bool overriddenAffectsABI, needsNewTableEntry, isTransparent;
|
|
DeclID opaqueReturnTypeID;
|
|
bool isUserAccessible;
|
|
bool isDistributedThunk;
|
|
bool hasSendingResult = false;
|
|
ArrayRef<uint64_t> nameAndDependencyIDs;
|
|
|
|
if (!isAccessor) {
|
|
decls_block::FuncLayout::readRecord(scratch, contextID, isImplicit,
|
|
isStatic, rawStaticSpelling, isObjC,
|
|
rawMutModifier,
|
|
hasForcedStaticDispatch,
|
|
async, throws, thrownTypeID,
|
|
genericSigID,
|
|
resultInterfaceTypeID,
|
|
isIUO,
|
|
associatedDeclID, overriddenID,
|
|
overriddenAffectsABI,
|
|
numNameComponentsBiased,
|
|
rawAccessLevel,
|
|
needsNewTableEntry,
|
|
opaqueReturnTypeID,
|
|
isUserAccessible,
|
|
isDistributedThunk,
|
|
hasSendingResult,
|
|
nameAndDependencyIDs);
|
|
} else {
|
|
decls_block::AccessorLayout::readRecord(scratch, contextID, isImplicit,
|
|
isStatic, rawStaticSpelling, isObjC,
|
|
rawMutModifier,
|
|
hasForcedStaticDispatch,
|
|
async, throws, thrownTypeID,
|
|
genericSigID,
|
|
resultInterfaceTypeID,
|
|
isIUO,
|
|
overriddenID,
|
|
overriddenAffectsABI,
|
|
accessorStorageDeclID,
|
|
rawAccessorKind,
|
|
rawAccessLevel,
|
|
needsNewTableEntry,
|
|
isTransparent,
|
|
isDistributedThunk,
|
|
nameAndDependencyIDs);
|
|
}
|
|
|
|
DeclDeserializationError::Flags errorFlags;
|
|
unsigned numTableEntries = needsNewTableEntry ? 1 : 0;
|
|
|
|
// Parse the accessor-specific fields.
|
|
AbstractStorageDecl *storage = nullptr;
|
|
AccessorKind accessorKind;
|
|
if (isAccessor) {
|
|
auto storageResult = MF.getDeclChecked(accessorStorageDeclID);
|
|
if (!storageResult ||
|
|
!(storage =
|
|
dyn_cast_or_null<AbstractStorageDecl>(storageResult.get()))) {
|
|
// FIXME: "TypeError" isn't exactly correct for this.
|
|
return llvm::make_error<TypeError>(
|
|
DeclName(), takeErrorInfo(storageResult.takeError()),
|
|
errorFlags, numTableEntries);
|
|
}
|
|
|
|
if (auto accessorKindResult = getActualAccessorKind(rawAccessorKind))
|
|
accessorKind = *accessorKindResult;
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
// Deserializing the storage declaration will cause a recurrence
|
|
// into this code. When we come out, don't create the accessor twice.
|
|
// TODO: find some better way of breaking this cycle, like lazily
|
|
// deserializing the accessors.
|
|
if (auto accessor = storage->getAccessor(accessorKind))
|
|
return accessor;
|
|
}
|
|
|
|
// Resolve the name ids.
|
|
DeclName name;
|
|
ArrayRef<uint64_t> dependencyIDs;
|
|
if (isAccessor) {
|
|
dependencyIDs = nameAndDependencyIDs;
|
|
} else {
|
|
Identifier baseName = MF.getIdentifier(nameAndDependencyIDs.front());
|
|
if (numNameComponentsBiased != 0) {
|
|
SmallVector<Identifier, 2> names;
|
|
for (auto nameID : nameAndDependencyIDs.slice(1,
|
|
numNameComponentsBiased-1)){
|
|
names.push_back(MF.getIdentifier(nameID));
|
|
}
|
|
name = DeclName(ctx, baseName, names);
|
|
dependencyIDs = nameAndDependencyIDs.slice(numNameComponentsBiased);
|
|
} else {
|
|
name = baseName;
|
|
dependencyIDs = nameAndDependencyIDs.drop_front();
|
|
}
|
|
}
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
Expected<Decl *> overriddenOrError = MF.getDeclChecked(overriddenID);
|
|
Decl *overridden;
|
|
if (overriddenOrError) {
|
|
overridden = overriddenOrError.get();
|
|
} else {
|
|
if (overriddenAffectsABI || !ctx.LangOpts.EnableDeserializationRecovery) {
|
|
MF.diagnoseAndConsumeError(overriddenOrError.takeError());
|
|
return llvm::make_error<OverrideError>(name, errorFlags,
|
|
numTableEntries);
|
|
}
|
|
// Pass through deserialization errors.
|
|
if (overriddenOrError.errorIsA<FatalDeserializationError>())
|
|
return overriddenOrError.takeError();
|
|
|
|
MF.diagnoseAndConsumeError(overriddenOrError.takeError());
|
|
overridden = nullptr;
|
|
}
|
|
|
|
for (TypeID dependencyID : dependencyIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()),
|
|
errorFlags, numTableEntries);
|
|
}
|
|
}
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
// Read generic params before reading the type, because the type may
|
|
// reference generic parameters, and we want them to have a dummy
|
|
// DeclContext for now.
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(DC));
|
|
|
|
auto staticSpelling = getActualStaticSpellingKind(rawStaticSpelling);
|
|
if (!staticSpelling.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto resultTypeOrError = MF.getTypeChecked(resultInterfaceTypeID);
|
|
if (!resultTypeOrError)
|
|
return resultTypeOrError.takeError();
|
|
const auto resultType = resultTypeOrError.get();
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto thrownTypeOrError = MF.getTypeChecked(thrownTypeID);
|
|
if (!thrownTypeOrError)
|
|
return thrownTypeOrError.takeError();
|
|
const auto thrownType = thrownTypeOrError.get();
|
|
|
|
FuncDecl *fn;
|
|
if (!isAccessor) {
|
|
fn = FuncDecl::createDeserialized(ctx, staticSpelling.value(), name,
|
|
async, throws, thrownType,
|
|
genericParams, resultType, DC);
|
|
} else {
|
|
auto *accessor =
|
|
AccessorDecl::createDeserialized(ctx, accessorKind, storage, async,
|
|
throws, thrownType, resultType, DC);
|
|
accessor->setIsTransparent(isTransparent);
|
|
|
|
fn = accessor;
|
|
}
|
|
declOrOffset = fn;
|
|
|
|
fn->setGenericSignature(MF.getGenericSignature(genericSigID));
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
fn->setAccess(*accessLevel);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
if (auto SelfAccessKind = getActualSelfAccessKind(rawMutModifier))
|
|
fn->setSelfAccessKind(*SelfAccessKind);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
if (!isAccessor) {
|
|
if (Decl *associated = MF.getDecl(associatedDeclID)) {
|
|
if (auto op = dyn_cast<OperatorDecl>(associated)) {
|
|
ctx.evaluator.cacheOutput(FunctionOperatorRequest{fn},
|
|
std::move(op));
|
|
|
|
if (isa<PrefixOperatorDecl>(op))
|
|
fn->addAttribute(new (ctx) PrefixAttr(/*implicit*/ false));
|
|
else if (isa<PostfixOperatorDecl>(op))
|
|
fn->addAttribute(new (ctx) PostfixAttr(/*implicit*/ false));
|
|
// Note that an explicit 'infix' is not required.
|
|
}
|
|
// Otherwise, unknown associated decl kind.
|
|
}
|
|
}
|
|
|
|
fn->setStatic(isStatic);
|
|
fn->setImplicitlyUnwrappedOptional(isIUO);
|
|
|
|
ParameterList *paramList;
|
|
SET_OR_RETURN_ERROR(paramList, MF.readParameterList());
|
|
fn->setParameters(paramList);
|
|
|
|
SmallVector<LifetimeDependenceInfo, 1> lifetimeDependencies;
|
|
while (auto info = MF.maybeReadLifetimeDependence()) {
|
|
assert(info.has_value());
|
|
lifetimeDependencies.push_back(*info);
|
|
}
|
|
|
|
ctx.evaluator.cacheOutput(LifetimeDependenceInfoRequest{fn},
|
|
lifetimeDependencies.empty()
|
|
? ArrayRef<LifetimeDependenceInfo>()
|
|
: ctx.AllocateCopy(lifetimeDependencies));
|
|
|
|
if (auto errorConvention = MF.maybeReadForeignErrorConvention())
|
|
fn->setForeignErrorConvention(*errorConvention);
|
|
if (auto asyncConvention = MF.maybeReadForeignAsyncConvention())
|
|
fn->setForeignAsyncConvention(*asyncConvention);
|
|
|
|
if (auto bodyText = MF.maybeReadInlinableBodyText())
|
|
fn->setBodyStringRepresentation(*bodyText);
|
|
|
|
fn->setOverriddenDecl(cast_or_null<FuncDecl>(overridden));
|
|
if (fn->getOverriddenDecl())
|
|
AddAttribute(new (ctx) OverrideAttr(SourceLoc()));
|
|
|
|
if (isImplicit)
|
|
fn->setImplicit();
|
|
fn->setIsObjC(isObjC);
|
|
fn->setForcedStaticDispatch(hasForcedStaticDispatch);
|
|
|
|
{
|
|
OpaqueTypeDecl *opaqueDecl = nullptr;
|
|
if (opaqueReturnTypeID) {
|
|
auto declOrError = MF.getDeclChecked(opaqueReturnTypeID);
|
|
if (!declOrError)
|
|
return declOrError.takeError();
|
|
|
|
opaqueDecl = cast<OpaqueTypeDecl>(declOrError.get());
|
|
}
|
|
ctx.evaluator.cacheOutput(OpaqueResultTypeRequest{fn},
|
|
std::move(opaqueDecl));
|
|
}
|
|
|
|
if (!isAccessor)
|
|
fn->setUserAccessible(isUserAccessible);
|
|
|
|
fn->setDistributedThunk(isDistributedThunk);
|
|
|
|
if (hasSendingResult)
|
|
fn->setSendingResult();
|
|
|
|
return fn;
|
|
}
|
|
|
|
Expected<Decl *> deserializeFunc(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
return deserializeAnyFunc(scratch, blobData, /*isAccessor*/false);
|
|
}
|
|
Expected<Decl *> deserializeAccessor(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
return deserializeAnyFunc(scratch, blobData, /*isAccessor*/true);
|
|
}
|
|
|
|
Expected<Decl *> deserializeOpaqueType(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
DeclID namingDeclID;
|
|
DeclContextID contextID;
|
|
GenericSignatureID interfaceSigID;
|
|
TypeID interfaceTypeID;
|
|
GenericSignatureID genericSigID;
|
|
uint8_t rawAccessLevel;
|
|
bool hasUnderlyingType;
|
|
bool exportUnderlyingType;
|
|
decls_block::OpaqueTypeLayout::readRecord(scratch, contextID,
|
|
namingDeclID, interfaceSigID,
|
|
interfaceTypeID, genericSigID,
|
|
rawAccessLevel,
|
|
hasUnderlyingType,
|
|
exportUnderlyingType);
|
|
|
|
DeclContext *declContext;
|
|
SET_OR_RETURN_ERROR(declContext, MF.getDeclContextChecked(contextID));
|
|
|
|
auto interfaceSigOrErr = MF.getGenericSignatureChecked(interfaceSigID);
|
|
if (!interfaceSigOrErr)
|
|
return interfaceSigOrErr.takeError();
|
|
|
|
// Check for reentrancy.
|
|
if (declOrOffset.isComplete())
|
|
return cast<OpaqueTypeDecl>(declOrOffset.get());
|
|
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(declContext));
|
|
|
|
// FIXME: Do we still need exportUnderlyingType?
|
|
uint64_t contextData = 0;
|
|
if (hasUnderlyingType &&
|
|
(exportUnderlyingType ||
|
|
MF.FileContext->getParentModule()->isMainModule())) {
|
|
contextData = MF.DeclTypeCursor.GetCurrentBitNo();
|
|
}
|
|
|
|
// Create the decl.
|
|
auto opaqueDecl = OpaqueTypeDecl::createDeserialized(
|
|
genericParams, declContext, interfaceSigOrErr.get(),
|
|
&MF, contextData);
|
|
declOrOffset = opaqueDecl;
|
|
|
|
auto namingDecl = cast<ValueDecl>(MF.getDecl(namingDeclID));
|
|
opaqueDecl->setNamingDecl(namingDecl);
|
|
|
|
if (contextData == 0) {
|
|
LLVM_DEBUG(
|
|
llvm::dbgs() << "Ignoring underlying information for opaque type of '";
|
|
llvm::dbgs() << namingDecl->getName();
|
|
llvm::dbgs() << "'\n");
|
|
} else {
|
|
LLVM_DEBUG(
|
|
llvm::dbgs() << "Loading underlying information for opaque type of '";
|
|
llvm::dbgs() << namingDecl->getName();
|
|
llvm::dbgs() << "'\n";
|
|
);
|
|
}
|
|
|
|
auto interfaceType = MF.getType(interfaceTypeID);
|
|
opaqueDecl->setInterfaceType(MetatypeType::get(interfaceType));
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
opaqueDecl->setAccess(*accessLevel);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
auto genericSig = MF.getGenericSignature(genericSigID);
|
|
if (genericSig)
|
|
opaqueDecl->setGenericSignature(genericSig);
|
|
else
|
|
opaqueDecl->setGenericSignature(GenericSignature());
|
|
|
|
return opaqueDecl;
|
|
}
|
|
|
|
Expected<Decl *> deserializePatternBinding(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
DeclContextID contextID;
|
|
bool isImplicit;
|
|
bool isStatic;
|
|
uint8_t RawStaticSpelling;
|
|
unsigned numPatterns;
|
|
ArrayRef<uint64_t> initContextIDs;
|
|
|
|
decls_block::PatternBindingLayout::readRecord(scratch, contextID,
|
|
isImplicit,
|
|
isStatic,
|
|
RawStaticSpelling,
|
|
numPatterns,
|
|
initContextIDs);
|
|
auto StaticSpelling = getActualStaticSpellingKind(RawStaticSpelling);
|
|
if (!StaticSpelling.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
DeclContext *dc;
|
|
SET_OR_RETURN_ERROR(dc, MF.getDeclContextChecked(contextID));
|
|
|
|
SmallVector<std::pair<Pattern *, DeclContextID>, 4> patterns;
|
|
for (unsigned i = 0; i != numPatterns; ++i) {
|
|
auto pattern = MF.readPattern(dc);
|
|
if (!pattern) {
|
|
// Pass through deserialization errors.
|
|
if (pattern.errorIsA<FatalDeserializationError>())
|
|
return pattern.takeError();
|
|
|
|
// Silently drop the pattern...
|
|
MF.diagnoseAndConsumeError(pattern.takeError());
|
|
// ...but continue to read any further patterns we're expecting.
|
|
continue;
|
|
}
|
|
|
|
patterns.emplace_back(pattern.get(), DeclContextID());
|
|
if (!initContextIDs.empty()) {
|
|
patterns.back().second =
|
|
DeclContextID::getFromOpaqueValue(initContextIDs[i]);
|
|
}
|
|
}
|
|
|
|
auto binding =
|
|
PatternBindingDecl::createDeserialized(ctx, SourceLoc(),
|
|
StaticSpelling.value(),
|
|
SourceLoc(), patterns.size(), dc);
|
|
declOrOffset = binding;
|
|
|
|
binding->setStatic(isStatic);
|
|
|
|
if (isImplicit)
|
|
binding->setImplicit();
|
|
|
|
for (unsigned i = 0; i != patterns.size(); ++i) {
|
|
binding->setPattern(i, patterns[i].first);
|
|
|
|
DeclContext *dcPattern;
|
|
SET_OR_RETURN_ERROR(dcPattern, MF.getDeclContextChecked(patterns[i].second));
|
|
if (dcPattern)
|
|
binding->setInitContext(i, cast<PatternBindingInitializer>(dcPattern));
|
|
}
|
|
|
|
return binding;
|
|
}
|
|
|
|
Expected<Decl *> deserializeProtocol(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
bool isImplicit, isClassBounded, isObjC, hasSelfOrAssocTypeRequirements;
|
|
DeclID superclassDeclID;
|
|
uint8_t rawAccessLevel;
|
|
ArrayRef<uint64_t> dependencyIDs;
|
|
|
|
decls_block::ProtocolLayout::readRecord(scratch, nameID, contextID,
|
|
isImplicit, isClassBounded, isObjC,
|
|
hasSelfOrAssocTypeRequirements,
|
|
superclassDeclID,
|
|
rawAccessLevel,
|
|
dependencyIDs);
|
|
|
|
Identifier name = MF.getIdentifier(nameID);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
for (TypeID dependencyID : dependencyIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()));
|
|
}
|
|
}
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto proto = MF.createDecl<ProtocolDecl>(
|
|
DC, SourceLoc(), SourceLoc(), name,
|
|
ArrayRef<PrimaryAssociatedTypeName>(), ArrayRef<InheritedEntry>(),
|
|
/*TrailingWhere=*/nullptr);
|
|
declOrOffset = proto;
|
|
|
|
auto *superclassDecl = dyn_cast_or_null<ClassDecl>(MF.getDecl(superclassDeclID));
|
|
|
|
ctx.evaluator.cacheOutput(SuperclassDeclRequest{proto},
|
|
std::move(superclassDecl));
|
|
ctx.evaluator.cacheOutput(ProtocolRequiresClassRequest{proto},
|
|
std::move(isClassBounded));
|
|
ctx.evaluator.cacheOutput(HasSelfOrAssociatedTypeRequirementsRequest{proto},
|
|
std::move(hasSelfOrAssocTypeRequirements));
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
proto->setAccess(*accessLevel);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
SmallVector<ProtocolDecl *, 2> inherited;
|
|
if (!MF.readInheritedProtocols(inherited))
|
|
return MF.diagnoseFatal();
|
|
|
|
ctx.evaluator.cacheOutput(InheritedProtocolsRequest{proto},
|
|
ctx.AllocateCopy(inherited));
|
|
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(DC));
|
|
assert(genericParams && "protocol with no generic parameters?");
|
|
ctx.evaluator.cacheOutput(GenericParamListRequest{proto},
|
|
std::move(genericParams));
|
|
|
|
if (isImplicit)
|
|
proto->setImplicit();
|
|
proto->setIsObjC(isObjC);
|
|
|
|
proto->setLazyRequirementSignature(
|
|
&MF, MF.DeclTypeCursor.GetCurrentBitNo());
|
|
if (llvm::Error Err = skipRequirementSignature(MF.DeclTypeCursor))
|
|
MF.fatal(std::move(Err));
|
|
|
|
proto->setLazyAssociatedTypeMembers(
|
|
&MF, MF.DeclTypeCursor.GetCurrentBitNo());
|
|
if (llvm::Error Err = skipAssociatedTypeMembers(MF.DeclTypeCursor))
|
|
MF.fatal(std::move(Err));
|
|
|
|
proto->setLazyPrimaryAssociatedTypeMembers(
|
|
&MF, MF.DeclTypeCursor.GetCurrentBitNo());
|
|
if (llvm::Error Err = skipPrimaryAssociatedTypeMembers(MF.DeclTypeCursor))
|
|
MF.fatal(std::move(Err));
|
|
|
|
proto->setMemberLoader(&MF, MF.DeclTypeCursor.GetCurrentBitNo());
|
|
|
|
return proto;
|
|
}
|
|
|
|
template <typename OperatorLayout, typename OperatorDecl>
|
|
Expected<Decl *> deserializeUnaryOperator(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
|
|
OperatorLayout::readRecord(scratch, nameID, contextID);
|
|
|
|
Identifier name = MF.getIdentifier(nameID);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
auto result = MF.createDecl<OperatorDecl>(
|
|
DC, SourceLoc(), name, SourceLoc());
|
|
|
|
declOrOffset = result;
|
|
return result;
|
|
}
|
|
|
|
Expected<Decl *> deserializePrefixOperator(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
return deserializeUnaryOperator<decls_block::PrefixOperatorLayout,
|
|
PrefixOperatorDecl>(scratch, blobData);
|
|
}
|
|
|
|
Expected<Decl *> deserializePostfixOperator(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
return deserializeUnaryOperator<decls_block::PostfixOperatorLayout,
|
|
PostfixOperatorDecl>(scratch, blobData);
|
|
}
|
|
|
|
Expected<Decl *> deserializeInfixOperator(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
DeclID precedenceGroupID;
|
|
|
|
decls_block::InfixOperatorLayout::readRecord(scratch, nameID, contextID,
|
|
precedenceGroupID);
|
|
Identifier name = MF.getIdentifier(nameID);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
Expected<Decl *> precedenceGroup = MF.getDeclChecked(precedenceGroupID);
|
|
if (!precedenceGroup)
|
|
return precedenceGroup.takeError();
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
auto result = MF.createDecl<InfixOperatorDecl>(
|
|
DC, SourceLoc(), name, SourceLoc(), SourceLoc(), Identifier(),
|
|
SourceLoc());
|
|
ctx.evaluator.cacheOutput(
|
|
OperatorPrecedenceGroupRequest{result},
|
|
std::move(cast_or_null<PrecedenceGroupDecl>(precedenceGroup.get())));
|
|
|
|
declOrOffset = result;
|
|
return result;
|
|
}
|
|
|
|
Expected<Decl *> deserializePrecedenceGroup(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
uint8_t rawAssociativity;
|
|
bool assignment;
|
|
unsigned numHigherThan;
|
|
ArrayRef<uint64_t> rawRelations;
|
|
|
|
decls_block::PrecedenceGroupLayout::readRecord(scratch, nameID, contextID,
|
|
rawAssociativity,
|
|
assignment, numHigherThan,
|
|
rawRelations);
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
auto associativity = getActualAssociativity(rawAssociativity);
|
|
if (!associativity.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
if (numHigherThan > rawRelations.size())
|
|
return MF.diagnoseFatal();
|
|
|
|
SmallVector<PrecedenceGroupDecl::Relation, 4> higherThan;
|
|
for (auto relID : rawRelations.slice(0, numHigherThan)) {
|
|
PrecedenceGroupDecl *rel = nullptr;
|
|
if (relID)
|
|
rel = dyn_cast_or_null<PrecedenceGroupDecl>(MF.getDecl(relID));
|
|
if (!rel)
|
|
return MF.diagnoseFatal();
|
|
|
|
higherThan.push_back({SourceLoc(), rel->getName(), rel});
|
|
}
|
|
|
|
SmallVector<PrecedenceGroupDecl::Relation, 4> lowerThan;
|
|
for (auto relID : rawRelations.slice(numHigherThan)) {
|
|
PrecedenceGroupDecl *rel = nullptr;
|
|
if (relID)
|
|
rel = dyn_cast_or_null<PrecedenceGroupDecl>(MF.getDecl(relID));
|
|
if (!rel)
|
|
return MF.diagnoseFatal();
|
|
|
|
lowerThan.push_back({SourceLoc(), rel->getName(), rel});
|
|
}
|
|
|
|
declOrOffset = PrecedenceGroupDecl::create(DC, SourceLoc(), SourceLoc(),
|
|
MF.getIdentifier(nameID),
|
|
SourceLoc(),
|
|
SourceLoc(), SourceLoc(),
|
|
*associativity,
|
|
SourceLoc(), SourceLoc(),
|
|
assignment,
|
|
SourceLoc(), higherThan,
|
|
SourceLoc(), lowerThan,
|
|
SourceLoc());
|
|
return declOrOffset.get();
|
|
}
|
|
|
|
Expected<Decl *> deserializeClass(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
bool isImplicit, isObjC;
|
|
bool isExplicitActorDecl;
|
|
bool inheritsSuperclassInitializers;
|
|
bool hasMissingDesignatedInits;
|
|
GenericSignatureID genericSigID;
|
|
TypeID superclassID;
|
|
uint8_t rawAccessLevel;
|
|
unsigned numConformances, numInheritedTypes;
|
|
ArrayRef<uint64_t> rawIDs;
|
|
decls_block::ClassLayout::readRecord(scratch, nameID, contextID,
|
|
isImplicit, isObjC,
|
|
isExplicitActorDecl,
|
|
inheritsSuperclassInitializers,
|
|
hasMissingDesignatedInits,
|
|
genericSigID, superclassID,
|
|
rawAccessLevel, numConformances,
|
|
numInheritedTypes,
|
|
rawIDs);
|
|
|
|
Identifier name = MF.getIdentifier(nameID);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
auto conformanceIDs = rawIDs.slice(0, numConformances);
|
|
rawIDs = rawIDs.slice(numConformances);
|
|
auto inheritedIDs = rawIDs.slice(0, numInheritedTypes);
|
|
auto dependencyIDs = rawIDs.slice(numInheritedTypes);
|
|
|
|
for (TypeID dependencyID : dependencyIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()));
|
|
}
|
|
}
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(DC));
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto theClass = MF.createDecl<ClassDecl>(
|
|
SourceLoc(), name, SourceLoc(), ArrayRef<InheritedEntry>(),
|
|
genericParams, DC, isExplicitActorDecl);
|
|
declOrOffset = theClass;
|
|
|
|
theClass->setGenericSignature(MF.getGenericSignature(genericSigID));
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
theClass->setAccess(*accessLevel);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
theClass->setAddedImplicitInitializers();
|
|
if (isImplicit)
|
|
theClass->setImplicit();
|
|
theClass->setIsObjC(isObjC);
|
|
|
|
Type superclass;
|
|
SET_OR_RETURN_ERROR(superclass, MF.getTypeChecked(superclassID));
|
|
theClass->setSuperclass(superclass);
|
|
|
|
ctx.evaluator.cacheOutput(InheritsSuperclassInitializersRequest{theClass},
|
|
std::move(inheritsSuperclassInitializers));
|
|
ctx.evaluator.cacheOutput(HasMissingDesignatedInitializersRequest{theClass},
|
|
std::move(hasMissingDesignatedInits));
|
|
|
|
handleInherited(theClass, inheritedIDs);
|
|
|
|
theClass->setMemberLoader(&MF, MF.DeclTypeCursor.GetCurrentBitNo());
|
|
skipRecord(MF.DeclTypeCursor, decls_block::MEMBERS);
|
|
theClass->setConformanceLoader(
|
|
&MF, MF.createLazyConformanceLoaderToken(conformanceIDs));
|
|
|
|
return theClass;
|
|
}
|
|
|
|
Expected<Decl *> deserializeEnum(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
IdentifierID nameID;
|
|
DeclContextID contextID;
|
|
bool isImplicit;
|
|
bool isObjC;
|
|
GenericSignatureID genericSigID;
|
|
TypeID rawTypeID;
|
|
uint8_t rawAccessLevel;
|
|
unsigned numConformances, numInherited;
|
|
ArrayRef<uint64_t> rawIDs;
|
|
|
|
decls_block::EnumLayout::readRecord(scratch, nameID, contextID,
|
|
isImplicit, isObjC, genericSigID,
|
|
rawTypeID, rawAccessLevel,
|
|
numConformances, numInherited,
|
|
rawIDs);
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
Identifier name = MF.getIdentifier(nameID);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
auto conformanceIDs = rawIDs.slice(0, numConformances);
|
|
rawIDs = rawIDs.slice(numConformances);
|
|
auto inheritedIDs = rawIDs.slice(0, numInherited);
|
|
auto dependencyIDs = rawIDs.slice(numInherited);
|
|
|
|
for (TypeID dependencyID : dependencyIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()));
|
|
}
|
|
}
|
|
|
|
auto DCOrError = MF.getDeclContextChecked(contextID);
|
|
if (!DCOrError)
|
|
return DCOrError.takeError();
|
|
auto DC = DCOrError.get();
|
|
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(DC));
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto theEnum =
|
|
MF.createDecl<EnumDecl>(SourceLoc(), name, SourceLoc(),
|
|
ArrayRef<InheritedEntry>(), genericParams, DC);
|
|
|
|
declOrOffset = theEnum;
|
|
|
|
theEnum->setGenericSignature(MF.getGenericSignature(genericSigID));
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
theEnum->setAccess(*accessLevel);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
theEnum->setAddedImplicitInitializers();
|
|
// @objc enums have all their raw values checked.
|
|
if (isObjC) {
|
|
theEnum->setHasFixedRawValues();
|
|
}
|
|
|
|
if (isImplicit)
|
|
theEnum->setImplicit();
|
|
theEnum->setIsObjC(isObjC);
|
|
|
|
Type rawType;
|
|
SET_OR_RETURN_ERROR(rawType, MF.getTypeChecked(rawTypeID));
|
|
theEnum->setRawType(rawType);
|
|
|
|
handleInherited(theEnum, inheritedIDs);
|
|
|
|
theEnum->setMemberLoader(&MF, MF.DeclTypeCursor.GetCurrentBitNo());
|
|
skipRecord(MF.DeclTypeCursor, decls_block::MEMBERS);
|
|
theEnum->setConformanceLoader(
|
|
&MF, MF.createLazyConformanceLoaderToken(conformanceIDs));
|
|
return theEnum;
|
|
}
|
|
|
|
Expected<Decl *> deserializeEnumElement(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
DeclContextID contextID;
|
|
bool isImplicit, hasPayload, isRawValueImplicit, isNegative;
|
|
unsigned rawValueKindID;
|
|
IdentifierID rawValueData;
|
|
unsigned numArgNames;
|
|
ArrayRef<uint64_t> argNameAndDependencyIDs;
|
|
|
|
decls_block::EnumElementLayout::readRecord(scratch, contextID,
|
|
isImplicit, hasPayload,
|
|
rawValueKindID,
|
|
isRawValueImplicit, isNegative,
|
|
rawValueData,
|
|
numArgNames,
|
|
argNameAndDependencyIDs);
|
|
|
|
// Resolve the name ids.
|
|
Identifier baseName = MF.getIdentifier(argNameAndDependencyIDs.front());
|
|
SmallVector<Identifier, 2> argNames;
|
|
for (auto argNameID : argNameAndDependencyIDs.slice(1, numArgNames-1))
|
|
argNames.push_back(MF.getIdentifier(argNameID));
|
|
DeclName compoundName(ctx, baseName, argNames);
|
|
DeclName name = argNames.empty() ? baseName : compoundName;
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
for (TypeID dependencyID : argNameAndDependencyIDs.slice(numArgNames)) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
// Enum elements never introduce missing members in their parent enum.
|
|
//
|
|
// A frozen enum cannot be laid out if its missing cases anyway,
|
|
// so the dependency mechanism ensures the entire enum fails to
|
|
// deserialize.
|
|
//
|
|
// For a resilient enum, we don't care and just drop the element
|
|
// and continue.
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()));
|
|
}
|
|
}
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto elem = MF.createDecl<EnumElementDecl>(SourceLoc(),
|
|
name,
|
|
nullptr,
|
|
SourceLoc(),
|
|
nullptr,
|
|
DC);
|
|
declOrOffset = elem;
|
|
|
|
// Read payload parameter list, if it exists.
|
|
if (hasPayload) {
|
|
ParameterList *paramList;
|
|
SET_OR_RETURN_ERROR(paramList, MF.readParameterList());
|
|
elem->setParameterList(paramList);
|
|
}
|
|
|
|
// Deserialize the literal raw value, if any.
|
|
switch ((EnumElementRawValueKind)rawValueKindID) {
|
|
case EnumElementRawValueKind::None:
|
|
break;
|
|
case EnumElementRawValueKind::IntegerLiteral: {
|
|
auto literalText = MF.getIdentifierText(rawValueData);
|
|
auto literal = new (ctx) IntegerLiteralExpr(literalText, SourceLoc(),
|
|
isRawValueImplicit);
|
|
if (isNegative)
|
|
literal->setNegative(SourceLoc());
|
|
elem->setRawValueExpr(literal);
|
|
}
|
|
}
|
|
|
|
if (isImplicit)
|
|
elem->setImplicit();
|
|
elem->setAccess(std::max(cast<EnumDecl>(DC)->getFormalAccess(),
|
|
AccessLevel::Internal));
|
|
|
|
SmallVector<LifetimeDependenceInfo, 1> lifetimeDependencies;
|
|
while (auto info = MF.maybeReadLifetimeDependence()) {
|
|
assert(info.has_value());
|
|
lifetimeDependencies.push_back(*info);
|
|
}
|
|
|
|
ctx.evaluator.cacheOutput(LifetimeDependenceInfoRequest{elem},
|
|
lifetimeDependencies.empty()
|
|
? ArrayRef<LifetimeDependenceInfo>()
|
|
: ctx.AllocateCopy(lifetimeDependencies));
|
|
|
|
return elem;
|
|
}
|
|
|
|
Expected<Decl *> deserializeSubscript(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
DeclContextID contextID;
|
|
bool isImplicit, isObjC, isGetterMutating, isSetterMutating;
|
|
GenericSignatureID genericSigID;
|
|
TypeID elemInterfaceTypeID;
|
|
bool isIUO;
|
|
ModuleFile::AccessorRecord accessors;
|
|
DeclID overriddenID, opaqueReturnTypeID;
|
|
uint8_t rawAccessLevel, rawSetterAccessLevel, rawStaticSpelling;
|
|
uint8_t opaqueReadOwnership, readImpl, writeImpl, readWriteImpl;
|
|
unsigned numArgNames, numAccessors;
|
|
unsigned numTableEntries;
|
|
ArrayRef<uint64_t> argNameAndDependencyIDs;
|
|
|
|
decls_block::SubscriptLayout::readRecord(scratch, contextID,
|
|
isImplicit, isObjC,
|
|
isGetterMutating, isSetterMutating,
|
|
opaqueReadOwnership,
|
|
readImpl, writeImpl, readWriteImpl,
|
|
numAccessors,
|
|
genericSigID,
|
|
elemInterfaceTypeID,
|
|
isIUO,
|
|
overriddenID, rawAccessLevel,
|
|
rawSetterAccessLevel,
|
|
rawStaticSpelling, numArgNames,
|
|
opaqueReturnTypeID,
|
|
numTableEntries,
|
|
argNameAndDependencyIDs);
|
|
// Resolve the name ids.
|
|
SmallVector<Identifier, 2> argNames;
|
|
for (auto argNameID : argNameAndDependencyIDs.slice(0, numArgNames))
|
|
argNames.push_back(MF.getIdentifier(argNameID));
|
|
DeclName name(ctx, DeclBaseName::createSubscript(), argNames);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
argNameAndDependencyIDs = argNameAndDependencyIDs.slice(numArgNames);
|
|
|
|
// Extract the accessor IDs.
|
|
for (DeclID accessorID : argNameAndDependencyIDs.slice(0, numAccessors)) {
|
|
accessors.IDs.push_back(accessorID);
|
|
}
|
|
argNameAndDependencyIDs = argNameAndDependencyIDs.slice(numAccessors);
|
|
|
|
Expected<Decl *> overridden = MF.getDeclChecked(overriddenID);
|
|
if (!overridden) {
|
|
// Pass through deserialization errors.
|
|
if (overridden.errorIsA<FatalDeserializationError>())
|
|
return overridden.takeError();
|
|
MF.diagnoseAndConsumeError(overridden.takeError());
|
|
|
|
DeclDeserializationError::Flags errorFlags;
|
|
return llvm::make_error<OverrideError>(
|
|
name, errorFlags, numTableEntries);
|
|
}
|
|
|
|
for (TypeID dependencyID : argNameAndDependencyIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
DeclDeserializationError::Flags errorFlags;
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()),
|
|
errorFlags, numTableEntries);
|
|
}
|
|
}
|
|
|
|
DeclContext *parent;
|
|
SET_OR_RETURN_ERROR(parent, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(parent));
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto staticSpelling = getActualStaticSpellingKind(rawStaticSpelling);
|
|
if (!staticSpelling.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
const auto elemInterfaceType = MF.getType(elemInterfaceTypeID);
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto *const subscript = SubscriptDecl::createDeserialized(
|
|
ctx, name, *staticSpelling, elemInterfaceType, parent, genericParams);
|
|
subscript->setIsGetterMutating(isGetterMutating);
|
|
subscript->setIsSetterMutating(isSetterMutating);
|
|
declOrOffset = subscript;
|
|
|
|
subscript->setGenericSignature(MF.getGenericSignature(genericSigID));
|
|
|
|
ParameterList *paramList;
|
|
SET_OR_RETURN_ERROR(paramList, MF.readParameterList());
|
|
subscript->setIndices(paramList);
|
|
|
|
MF.configureStorage(subscript, opaqueReadOwnership,
|
|
readImpl, writeImpl, readWriteImpl, accessors);
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
subscript->setAccess(*accessLevel);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
|
|
if (subscript->supportsMutation()) {
|
|
if (auto setterAccess = getActualAccessLevel(rawSetterAccessLevel))
|
|
subscript->setSetterAccess(*setterAccess);
|
|
else
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
subscript->setImplicitlyUnwrappedOptional(isIUO);
|
|
|
|
if (isImplicit)
|
|
subscript->setImplicit();
|
|
subscript->setIsObjC(isObjC);
|
|
subscript->setOverriddenDecl(cast_or_null<SubscriptDecl>(overridden.get()));
|
|
if (subscript->getOverriddenDecl())
|
|
AddAttribute(new (ctx) OverrideAttr(SourceLoc()));
|
|
|
|
{
|
|
OpaqueTypeDecl *opaqueDecl = nullptr;
|
|
if (opaqueReturnTypeID) {
|
|
Decl *opaqueReturnType;
|
|
SET_OR_RETURN_ERROR(opaqueReturnType,
|
|
MF.getDeclChecked(opaqueReturnTypeID));
|
|
|
|
opaqueDecl = cast<OpaqueTypeDecl>(opaqueReturnType);
|
|
}
|
|
ctx.evaluator.cacheOutput(OpaqueResultTypeRequest{subscript},
|
|
std::move(opaqueDecl));
|
|
}
|
|
|
|
return subscript;
|
|
}
|
|
|
|
Expected<Decl *> deserializeExtension(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
TypeID extendedTypeID;
|
|
DeclID extendedNominalID;
|
|
DeclContextID contextID;
|
|
bool isImplicit;
|
|
GenericSignatureID genericSigID;
|
|
unsigned numConformances, numInherited;
|
|
ArrayRef<uint64_t> data;
|
|
|
|
decls_block::ExtensionLayout::readRecord(scratch, extendedTypeID,
|
|
extendedNominalID, contextID,
|
|
isImplicit, genericSigID,
|
|
numConformances, numInherited,
|
|
data);
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
auto conformanceIDs = data.slice(0, numConformances);
|
|
data = data.slice(numConformances);
|
|
auto inheritedIDs = data.slice(0, numInherited);
|
|
data = data.slice(numInherited);
|
|
auto dependencyIDs = data;
|
|
|
|
for (TypeID dependencyID : dependencyIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
return llvm::make_error<ExtensionError>(
|
|
takeErrorInfo(dependency.takeError()));
|
|
}
|
|
}
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto extension = ExtensionDecl::create(ctx, SourceLoc(), nullptr, { },
|
|
DC, nullptr);
|
|
declOrOffset = extension;
|
|
|
|
// Generic parameter lists are written from outermost to innermost.
|
|
// Keep reading until we run out of generic parameter lists.
|
|
GenericParamList *outerParams = nullptr;
|
|
while (true) {
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(DC));
|
|
if (!genericParams)
|
|
break;
|
|
|
|
genericParams->setOuterParameters(outerParams);
|
|
|
|
// Set up the DeclContexts for the GenericTypeParamDecls in the list.
|
|
for (auto param : *genericParams)
|
|
param->setDeclContext(extension);
|
|
|
|
outerParams = genericParams;
|
|
}
|
|
ctx.evaluator.cacheOutput(GenericParamListRequest{extension},
|
|
std::move(outerParams));
|
|
|
|
extension->setGenericSignature(MF.getGenericSignature(genericSigID));
|
|
|
|
auto extendedType = MF.getType(extendedTypeID);
|
|
ctx.evaluator.cacheOutput(ExtendedTypeRequest{extension},
|
|
std::move(extendedType));
|
|
auto nominal = dyn_cast_or_null<NominalTypeDecl>(MF.getDecl(extendedNominalID));
|
|
extension->setExtendedNominal(nominal);
|
|
|
|
if (isImplicit)
|
|
extension->setImplicit();
|
|
|
|
handleInherited(extension, inheritedIDs);
|
|
|
|
extension->setMemberLoader(&MF, MF.DeclTypeCursor.GetCurrentBitNo());
|
|
skipRecord(MF.DeclTypeCursor, decls_block::MEMBERS);
|
|
extension->setConformanceLoader(
|
|
&MF, MF.createLazyConformanceLoaderToken(conformanceIDs));
|
|
|
|
if (nominal) {
|
|
nominal->addExtension(extension);
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
if (outerParams) {
|
|
unsigned paramCount = 0;
|
|
for (auto *paramList = outerParams;
|
|
paramList != nullptr;
|
|
paramList = paramList->getOuterParameters()) {
|
|
paramCount += paramList->size();
|
|
}
|
|
assert(paramCount ==
|
|
extension->getGenericSignature().getGenericParams().size());
|
|
}
|
|
#endif
|
|
|
|
return extension;
|
|
}
|
|
|
|
Expected<Decl *> deserializeDestructor(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
DeclContextID contextID;
|
|
bool isImplicit, isObjC;
|
|
GenericSignatureID genericSigID;
|
|
|
|
decls_block::DestructorLayout::readRecord(scratch, contextID,
|
|
isImplicit, isObjC,
|
|
genericSigID);
|
|
|
|
DeclContext *DC;
|
|
SET_OR_RETURN_ERROR(DC, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto dtor = MF.createDecl<DestructorDecl>(SourceLoc(), DC);
|
|
declOrOffset = dtor;
|
|
|
|
if (auto bodyText = MF.maybeReadInlinableBodyText())
|
|
dtor->setBodyStringRepresentation(*bodyText);
|
|
|
|
dtor->setGenericSignature(MF.getGenericSignature(genericSigID));
|
|
|
|
auto *nom = cast<NominalTypeDecl>(DC->getImplementedObjCContext());
|
|
dtor->setAccess(std::max(nom->getFormalAccess(), AccessLevel::Internal));
|
|
|
|
if (isImplicit)
|
|
dtor->setImplicit();
|
|
dtor->setIsObjC(isObjC);
|
|
|
|
return dtor;
|
|
}
|
|
|
|
Expected<Decl *> deserializeMacro(ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
DeclContextID contextID;
|
|
bool isImplicit, hasParameterList;
|
|
GenericSignatureID genericSigID;
|
|
TypeID resultInterfaceTypeID;
|
|
uint8_t rawAccessLevel;
|
|
unsigned numArgNames;
|
|
unsigned builtinID;
|
|
uint8_t hasExpandedMacroDefinition;
|
|
IdentifierID externalModuleNameID;
|
|
IdentifierID externalMacroTypeNameID;
|
|
|
|
ArrayRef<uint64_t> argNameAndDependencyIDs;
|
|
|
|
decls_block::MacroLayout::readRecord(scratch, contextID,
|
|
isImplicit,
|
|
genericSigID,
|
|
hasParameterList,
|
|
resultInterfaceTypeID,
|
|
rawAccessLevel,
|
|
numArgNames,
|
|
builtinID,
|
|
hasExpandedMacroDefinition,
|
|
externalModuleNameID,
|
|
externalMacroTypeNameID,
|
|
argNameAndDependencyIDs);
|
|
|
|
// Get the base name.
|
|
DeclBaseName baseName = MF.getDeclBaseName(argNameAndDependencyIDs.front());
|
|
argNameAndDependencyIDs = argNameAndDependencyIDs.drop_front();
|
|
|
|
// Resolve the name ids.
|
|
DeclName name;
|
|
SmallVector<Identifier, 2> argNames;
|
|
for (auto argNameID : argNameAndDependencyIDs.slice(0, numArgNames))
|
|
argNames.push_back(MF.getIdentifier(argNameID));
|
|
name = DeclName(ctx, baseName, argNames);
|
|
PrettySupplementalDeclNameTrace trace(name);
|
|
|
|
argNameAndDependencyIDs = argNameAndDependencyIDs.slice(numArgNames);
|
|
|
|
// Check dependency types.
|
|
for (TypeID dependencyID : argNameAndDependencyIDs) {
|
|
auto dependency = MF.getTypeChecked(dependencyID);
|
|
if (!dependency) {
|
|
DeclDeserializationError::Flags errorFlags;
|
|
return llvm::make_error<TypeError>(
|
|
name, takeErrorInfo(dependency.takeError()),
|
|
errorFlags);
|
|
}
|
|
}
|
|
|
|
DeclContext *parent;
|
|
SET_OR_RETURN_ERROR(parent, MF.getDeclContextChecked(contextID));
|
|
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
GenericParamList *genericParams;
|
|
SET_OR_RETURN_ERROR(genericParams, MF.maybeReadGenericParams(parent));
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
const auto resultInterfaceType = MF.getType(resultInterfaceTypeID);
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
auto *macro = new (ctx) MacroDecl(SourceLoc(), name, SourceLoc(),
|
|
genericParams, nullptr,
|
|
SourceLoc(),
|
|
nullptr,
|
|
nullptr,
|
|
parent);
|
|
declOrOffset = macro;
|
|
|
|
macro->setGenericSignature(MF.getGenericSignature(genericSigID));
|
|
macro->resultType.setType(resultInterfaceType);
|
|
|
|
if (hasParameterList) {
|
|
SET_OR_RETURN_ERROR(macro->parameterList, MF.readParameterList());
|
|
}
|
|
|
|
if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
|
|
macro->setAccess(*accessLevel);
|
|
else
|
|
MF.fatal();
|
|
|
|
if (isImplicit)
|
|
macro->setImplicit();
|
|
|
|
// Record definition
|
|
if (builtinID) {
|
|
std::optional<BuiltinMacroKind> builtinKind;
|
|
switch (builtinID) {
|
|
case 1:
|
|
builtinKind = BuiltinMacroKind::ExternalMacro;
|
|
break;
|
|
|
|
case 2:
|
|
builtinKind = BuiltinMacroKind::IsolationMacro;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (builtinKind) {
|
|
ctx.evaluator.cacheOutput(
|
|
MacroDefinitionRequest{macro},
|
|
MacroDefinition::forBuiltin(*builtinKind)
|
|
);
|
|
}
|
|
} else if (externalModuleNameID > 0) {
|
|
ctx.evaluator.cacheOutput(
|
|
MacroDefinitionRequest{macro},
|
|
MacroDefinition::forExternal(
|
|
MF.getIdentifier(externalModuleNameID),
|
|
MF.getIdentifier(externalMacroTypeNameID)
|
|
)
|
|
);
|
|
} else if (hasExpandedMacroDefinition) {
|
|
// Macro expansion definition block.
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return macro;
|
|
|
|
SmallVector<uint64_t, 16> scratch;
|
|
scratch.clear();
|
|
StringRef expansionText;
|
|
unsigned recordID = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &expansionText));
|
|
if (recordID != decls_block::EXPANDED_MACRO_DEFINITION)
|
|
return macro;
|
|
|
|
uint8_t hasReplacements;
|
|
decls_block::ExpandedMacroDefinitionLayout::readRecord(
|
|
scratch, hasReplacements);
|
|
|
|
// Macro replacements block.
|
|
SmallVector<ExpandedMacroReplacement, 2> replacements;
|
|
SmallVector<ExpandedMacroReplacement, 2> genericReplacements;
|
|
if (hasReplacements) {
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind == llvm::BitstreamEntry::Record) {
|
|
scratch.clear();
|
|
unsigned recordID = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != decls_block::EXPANDED_MACRO_REPLACEMENTS)
|
|
return macro;
|
|
|
|
ArrayRef<uint64_t> serializedReplacements;
|
|
decls_block::ExpandedMacroReplacementsLayout::readRecord(
|
|
scratch, serializedReplacements);
|
|
if (serializedReplacements.size() % 3 == 0) {
|
|
for (unsigned i : range(0, serializedReplacements.size() / 3)) {
|
|
ExpandedMacroReplacement replacement{
|
|
static_cast<unsigned>(serializedReplacements[3*i]),
|
|
static_cast<unsigned>(serializedReplacements[3*i + 1]),
|
|
static_cast<unsigned>(serializedReplacements[3*i + 2])
|
|
};
|
|
replacements.push_back(replacement);
|
|
}
|
|
}
|
|
|
|
ArrayRef<uint64_t> serializedGenericReplacements;
|
|
decls_block::ExpandedMacroReplacementsLayout::readRecord(
|
|
scratch, serializedGenericReplacements);
|
|
if (serializedGenericReplacements.size() % 3 == 0) {
|
|
for (unsigned i : range(0, serializedGenericReplacements.size() / 3)) {
|
|
ExpandedMacroReplacement genericReplacement{
|
|
static_cast<unsigned>(serializedGenericReplacements[3*i]),
|
|
static_cast<unsigned>(serializedGenericReplacements[3*i + 1]),
|
|
static_cast<unsigned>(serializedGenericReplacements[3*i + 2])
|
|
};
|
|
genericReplacements.push_back(genericReplacement);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ctx.evaluator.cacheOutput(
|
|
MacroDefinitionRequest{macro},
|
|
MacroDefinition::forExpanded(ctx, expansionText, replacements, genericReplacements)
|
|
);
|
|
}
|
|
|
|
return macro;
|
|
}
|
|
|
|
Expected<AvailableAttr *>
|
|
readAvailable_DECL_ATTR(SmallVectorImpl<uint64_t> &scratch,
|
|
StringRef blobData);
|
|
};
|
|
}
|
|
|
|
Expected<Decl *>
|
|
ModuleFile::getDeclChecked(
|
|
DeclID DID,
|
|
llvm::function_ref<bool(DeclAttributes)> matchAttributes) {
|
|
if (DID == 0)
|
|
return nullptr;
|
|
|
|
assert(DID <= Decls.size() && "invalid decl ID");
|
|
auto &declOrOffset = Decls[DID-1];
|
|
|
|
if (!declOrOffset.isComplete()) {
|
|
++NumDeclsLoaded;
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error =
|
|
diagnoseFatalIfNotSuccess(DeclTypeCursor.JumpToBit(declOrOffset)))
|
|
return std::move(error);
|
|
|
|
Expected<Decl *> deserialized =
|
|
DeclDeserializer(*this, declOrOffset).getDeclCheckedImpl(
|
|
matchAttributes);
|
|
if (!deserialized)
|
|
return deserialized;
|
|
} else if (matchAttributes) {
|
|
// Decl was cached but we may need to filter it
|
|
if (!matchAttributes(declOrOffset.get()->getAttrs()))
|
|
return llvm::make_error<DeclAttributesDidNotMatch>();
|
|
}
|
|
|
|
// Tag every deserialized ValueDecl coming out of getDeclChecked with its ID.
|
|
assert(declOrOffset.isComplete());
|
|
if (auto *IDC = dyn_cast_or_null<IterableDeclContext>(declOrOffset.get())) {
|
|
// Only set the DeclID on the returned Decl if it's one that was loaded
|
|
// and _wasn't_ one that had its DeclID set elsewhere (a followed XREF).
|
|
if (IDC->wasDeserialized() &&
|
|
static_cast<uint32_t>(IDC->getDeclID()) == 0) {
|
|
IDC->setDeclID(DID);
|
|
}
|
|
}
|
|
|
|
LLVM_DEBUG(
|
|
if (auto *VD = dyn_cast_or_null<ValueDecl>(declOrOffset.get())) {
|
|
llvm::dbgs() << "Deserialized: '";
|
|
llvm::dbgs() << VD->getName();
|
|
llvm::dbgs() << "'\n";
|
|
});
|
|
|
|
return declOrOffset;
|
|
}
|
|
|
|
static std::optional<AvailabilityDomainKind>
|
|
decodeDomainKind(uint8_t kind) {
|
|
switch (kind) {
|
|
case static_cast<uint8_t>(AvailabilityDomainKind::Universal):
|
|
return AvailabilityDomainKind::Universal;
|
|
case static_cast<uint8_t>(AvailabilityDomainKind::SwiftLanguageMode):
|
|
return AvailabilityDomainKind::SwiftLanguageMode;
|
|
case static_cast<uint8_t>(AvailabilityDomainKind::StandaloneSwiftRuntime):
|
|
return AvailabilityDomainKind::StandaloneSwiftRuntime;
|
|
case static_cast<uint8_t>(AvailabilityDomainKind::PackageDescription):
|
|
return AvailabilityDomainKind::PackageDescription;
|
|
case static_cast<uint8_t>(AvailabilityDomainKind::Embedded):
|
|
return AvailabilityDomainKind::Embedded;
|
|
case static_cast<uint8_t>(AvailabilityDomainKind::Platform):
|
|
return AvailabilityDomainKind::Platform;
|
|
case static_cast<uint8_t>(AvailabilityDomainKind::Custom):
|
|
return AvailabilityDomainKind::Custom;
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
static AvailabilityDomain
|
|
decodeNonCustomAvailabilityDomain(AvailabilityDomainKind domainKind,
|
|
PlatformKind platformKind) {
|
|
switch (domainKind) {
|
|
case AvailabilityDomainKind::Universal:
|
|
return AvailabilityDomain::forUniversal();
|
|
case AvailabilityDomainKind::SwiftLanguageMode:
|
|
return AvailabilityDomain::forSwiftLanguageMode();
|
|
case AvailabilityDomainKind::StandaloneSwiftRuntime:
|
|
return AvailabilityDomain::forStandaloneSwiftRuntime();
|
|
case AvailabilityDomainKind::PackageDescription:
|
|
return AvailabilityDomain::forPackageDescription();
|
|
case AvailabilityDomainKind::Embedded:
|
|
return AvailabilityDomain::forEmbedded();
|
|
case AvailabilityDomainKind::Platform:
|
|
return AvailabilityDomain::forPlatform(platformKind);
|
|
case AvailabilityDomainKind::Custom:
|
|
llvm_unreachable("custom domains aren't handled here");
|
|
return AvailabilityDomain::forUniversal();
|
|
}
|
|
}
|
|
|
|
Expected<AvailableAttr *>
|
|
DeclDeserializer::readAvailable_DECL_ATTR(SmallVectorImpl<uint64_t> &scratch,
|
|
StringRef blobData) {
|
|
bool isImplicit;
|
|
bool isUnavailable;
|
|
bool isDeprecated;
|
|
bool isNoAsync;
|
|
bool isSPI;
|
|
uint8_t rawDomainKind;
|
|
unsigned rawPlatform;
|
|
DeclID customDomainID;
|
|
DEF_VER_TUPLE_PIECES(Introduced);
|
|
DEF_VER_TUPLE_PIECES(Deprecated);
|
|
DEF_VER_TUPLE_PIECES(Obsoleted);
|
|
unsigned messageSize, renameSize;
|
|
|
|
// Decode the record, pulling the version tuple information.
|
|
serialization::decls_block::AvailableDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, isUnavailable, isDeprecated, isNoAsync, isSPI,
|
|
rawDomainKind, rawPlatform, customDomainID,
|
|
LIST_VER_TUPLE_PIECES(Introduced), LIST_VER_TUPLE_PIECES(Deprecated),
|
|
LIST_VER_TUPLE_PIECES(Obsoleted), messageSize, renameSize);
|
|
|
|
auto maybeDomainKind = decodeDomainKind(rawDomainKind);
|
|
if (!maybeDomainKind)
|
|
return llvm::make_error<InvalidEnumValueError>(rawDomainKind, "AvailabilityDomainKind");
|
|
|
|
auto maybePlatform = platformFromUnsigned(rawPlatform);
|
|
if (!maybePlatform.has_value())
|
|
return llvm::make_error<InvalidEnumValueError>(rawPlatform, "PlatformKind");
|
|
|
|
AvailabilityDomainKind domainKind = *maybeDomainKind;
|
|
PlatformKind platform = *maybePlatform;
|
|
StringRef message = blobData.substr(0, messageSize);
|
|
blobData = blobData.substr(messageSize);
|
|
StringRef rename = blobData.substr(0, renameSize);
|
|
llvm::VersionTuple Introduced, Deprecated, Obsoleted;
|
|
DECODE_VER_TUPLE(Introduced)
|
|
DECODE_VER_TUPLE(Deprecated)
|
|
DECODE_VER_TUPLE(Obsoleted)
|
|
|
|
AvailableAttr::Kind kind;
|
|
if (isUnavailable)
|
|
kind = AvailableAttr::Kind::Unavailable;
|
|
else if (isDeprecated)
|
|
kind = AvailableAttr::Kind::Deprecated;
|
|
else if (isNoAsync)
|
|
kind = AvailableAttr::Kind::NoAsync;
|
|
else
|
|
kind = AvailableAttr::Kind::Default;
|
|
|
|
AvailabilityDomain domain;
|
|
if (domainKind == AvailabilityDomainKind::Custom) {
|
|
if (customDomainID & 0x01) {
|
|
IdentifierID customDomainNameID = customDomainID >> 1;
|
|
Identifier customDomainName = MF.getIdentifier(customDomainNameID);
|
|
SmallVector<AvailabilityDomain, 1> foundDomains;
|
|
if (ctx.MainModule) {
|
|
ctx.MainModule->lookupAvailabilityDomains(
|
|
customDomainName, foundDomains);
|
|
}
|
|
|
|
if (foundDomains.size() == 1) {
|
|
domain = foundDomains[0];
|
|
} else {
|
|
ctx.Diags.diagnose(
|
|
SourceLoc(), diag::serialization_dropped_custom_availability,
|
|
customDomainName);
|
|
domain = AvailabilityDomain::forUniversal();
|
|
}
|
|
} else {
|
|
DeclID domainDeclID = customDomainID >> 1;
|
|
Decl *decodedDomainDecl = nullptr;
|
|
SET_OR_RETURN_ERROR(decodedDomainDecl, MF.getDeclChecked(domainDeclID));
|
|
|
|
if (decodedDomainDecl) {
|
|
auto domainDecl = dyn_cast<ValueDecl>(decodedDomainDecl);
|
|
if (!domainDecl)
|
|
return llvm::make_error<InvalidAvailabilityDomainError>();
|
|
|
|
if (auto customDomain = AvailabilityDomain::forCustom(domainDecl))
|
|
domain = *customDomain;
|
|
else
|
|
return llvm::make_error<InvalidAvailabilityDomainError>();
|
|
} else {
|
|
return llvm::make_error<InvalidAvailabilityDomainError>();
|
|
}
|
|
}
|
|
} else {
|
|
domain = decodeNonCustomAvailabilityDomain(domainKind, platform);
|
|
}
|
|
|
|
auto attr = new (ctx)
|
|
AvailableAttr(SourceLoc(), SourceRange(), domain, SourceLoc(), kind,
|
|
message, rename, Introduced, SourceRange(), Deprecated,
|
|
SourceRange(), Obsoleted, SourceRange(), isImplicit, isSPI);
|
|
return attr;
|
|
}
|
|
|
|
llvm::Error DeclDeserializer::deserializeCustomAttrs() {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 64> scratch;
|
|
StringRef blobData;
|
|
for (auto attrOffset : customAttrOffsets) {
|
|
if (auto error =
|
|
MF.diagnoseFatalIfNotSuccess(MF.DeclTypeCursor.JumpToBit(attrOffset)))
|
|
return error;
|
|
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance());
|
|
if (entry.Kind != llvm::BitstreamEntry::Record) {
|
|
// We don't know how to serialize decls represented by sub-blocks.
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
unsigned recordID = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
assert(recordID == decls_block::Custom_DECL_ATTR &&
|
|
"expecting only custom attributes in deserializeCustomAttrs");
|
|
|
|
bool isImplicit;
|
|
bool isArgUnsafe;
|
|
TypeID typeID;
|
|
serialization::decls_block::CustomDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, typeID, isArgUnsafe);
|
|
|
|
Expected<Type> deserialized = MF.getTypeChecked(typeID);
|
|
if (!deserialized) {
|
|
if (deserialized.errorIsA<XRefNonLoadedModuleError>() ||
|
|
MF.allowCompilerErrors()) {
|
|
// A custom attribute defined behind an implementation-only import
|
|
// is safe to drop when it can't be deserialized.
|
|
// rdar://problem/56599179. When allowing errors we're doing a best
|
|
// effort to create a module, so ignore in that case as well.
|
|
MF.diagnoseAndConsumeError(deserialized.takeError());
|
|
} else
|
|
return deserialized.takeError();
|
|
} else if (!deserialized.get() && MF.allowCompilerErrors()) {
|
|
// Serialized an invalid attribute, just skip it when allowing errors
|
|
} else {
|
|
// Note that the owner will be set in DeclDeserializer's destructor.
|
|
auto *TE = TypeExpr::createImplicit(deserialized.get(), ctx);
|
|
auto custom = CustomAttr::create(ctx, SourceLoc(), TE, CustomAttrOwner(),
|
|
isImplicit);
|
|
custom->setArgIsUnsafe(isArgUnsafe);
|
|
AddAttribute(custom);
|
|
}
|
|
scratch.clear();
|
|
}
|
|
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
llvm::Error DeclDeserializer::deserializeDeclCommon() {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 64> scratch;
|
|
StringRef blobData;
|
|
while (true) {
|
|
BCOffsetRAII restoreOffset(MF.DeclTypeCursor);
|
|
serialization::BitOffset attrOffset = MF.DeclTypeCursor.GetCurrentBitNo();
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance());
|
|
if (entry.Kind != llvm::BitstreamEntry::Record) {
|
|
// We don't know how to serialize decls represented by sub-blocks.
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
unsigned recordID = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
|
|
if (recordID == ERROR_FLAG) {
|
|
assert(!IsInvalid && "Error flag written multiple times");
|
|
IsInvalid = true;
|
|
} else if (recordID == ABI_ONLY_COUNTERPART) {
|
|
assert(ABIDeclCounterpartID == 0
|
|
&& "ABI-only counterpart written multiple times");
|
|
DeclID counterpartID;
|
|
serialization::decls_block::ABIOnlyCounterpartLayout::readRecord(
|
|
scratch, counterpartID);
|
|
// Defer resolving `ABIDeclCounterpartID` until `finishRecursiveAttrs()`
|
|
// because the two decls reference each other.
|
|
ABIDeclCounterpartID = counterpartID;
|
|
} else if (isDeclAttrRecord(recordID)) {
|
|
DeclAttribute *Attr = nullptr;
|
|
bool skipAttr = false;
|
|
switch (recordID) {
|
|
case decls_block::ABI_DECL_ATTR: {
|
|
bool isImplicit;
|
|
DeclID abiDeclID;
|
|
serialization::decls_block::ABIDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, abiDeclID);
|
|
Attr = new (ctx) ABIAttr(nullptr, isImplicit);
|
|
// Defer resolving `abiDeclID` until `finishRecursiveAttrs()` because
|
|
// the two decls reference each other.
|
|
unresolvedABIAttr.emplace(cast<ABIAttr>(Attr), abiDeclID);
|
|
break;
|
|
}
|
|
|
|
case decls_block::SILGenName_DECL_ATTR: {
|
|
bool isImplicit;
|
|
serialization::decls_block::SILGenNameDeclAttrLayout::readRecord(
|
|
scratch, isImplicit);
|
|
Attr = new (ctx) SILGenNameAttr(blobData, /*raw*/ false, isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Implements_DECL_ATTR: {
|
|
bool isImplicit;
|
|
DeclContextID contextID;
|
|
DeclID protocolID;
|
|
unsigned numNameComponentsBiased;
|
|
ArrayRef<uint64_t> nameIDs;
|
|
serialization::decls_block::ImplementsDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, contextID, protocolID, numNameComponentsBiased,
|
|
nameIDs);
|
|
|
|
// Resolve the context.
|
|
auto dcOrError = MF.getDeclContextChecked(contextID);
|
|
if (!dcOrError)
|
|
return dcOrError.takeError();
|
|
DeclContext *dc = dcOrError.get();
|
|
|
|
// Resolve the member name.
|
|
DeclName memberName;
|
|
Identifier baseName = MF.getIdentifier(nameIDs.front());
|
|
if (numNameComponentsBiased != 0) {
|
|
SmallVector<Identifier, 2> names;
|
|
for (auto nameID : nameIDs.slice(1, numNameComponentsBiased-1)) {
|
|
names.push_back(MF.getIdentifier(nameID));
|
|
}
|
|
memberName = DeclName(ctx, baseName, names);
|
|
} else {
|
|
memberName = baseName;
|
|
}
|
|
|
|
Expected<Decl *> protocolOrError = MF.getDeclChecked(protocolID);
|
|
ProtocolDecl *protocol;
|
|
if (protocolOrError) {
|
|
protocol = cast<ProtocolDecl>(protocolOrError.get());
|
|
} else {
|
|
return protocolOrError.takeError();
|
|
}
|
|
|
|
Attr = ImplementsAttr::create(dc, protocol, memberName);
|
|
break;
|
|
}
|
|
|
|
case decls_block::CDecl_DECL_ATTR: {
|
|
bool isImplicit;
|
|
bool isUnderscored;
|
|
serialization::decls_block::CDeclDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, isUnderscored);
|
|
Attr = new (ctx) CDeclAttr(blobData, isImplicit, isUnderscored);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Alignment_DECL_ATTR: {
|
|
bool isImplicit;
|
|
unsigned alignment;
|
|
serialization::decls_block::AlignmentDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, alignment);
|
|
Attr = new (ctx) AlignmentAttr(alignment, SourceLoc(), SourceRange(),
|
|
isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::SwiftNativeObjCRuntimeBase_DECL_ATTR: {
|
|
bool isImplicit;
|
|
IdentifierID nameID;
|
|
serialization::decls_block::SwiftNativeObjCRuntimeBaseDeclAttrLayout
|
|
::readRecord(scratch, isImplicit, nameID);
|
|
|
|
auto name = MF.getIdentifier(nameID);
|
|
Attr = new (ctx) SwiftNativeObjCRuntimeBaseAttr(name, SourceLoc(),
|
|
SourceRange(),
|
|
isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Semantics_DECL_ATTR: {
|
|
bool isImplicit;
|
|
serialization::decls_block::SemanticsDeclAttrLayout::readRecord(
|
|
scratch, isImplicit);
|
|
Attr = new (ctx) SemanticsAttr(blobData, isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Inline_DECL_ATTR: {
|
|
unsigned kind;
|
|
serialization::decls_block::InlineDeclAttrLayout::readRecord(
|
|
scratch, kind);
|
|
Attr = new (ctx) InlineAttr((InlineKind)kind);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Export_DECL_ATTR: {
|
|
unsigned kind;
|
|
serialization::decls_block::ExportDeclAttrLayout::readRecord(
|
|
scratch, kind);
|
|
Attr = new (ctx) ExportAttr((ExportKind)kind);
|
|
break;
|
|
}
|
|
|
|
case decls_block::NonSendable_DECL_ATTR: {
|
|
unsigned kind;
|
|
serialization::decls_block::NonSendableDeclAttrLayout::readRecord(
|
|
scratch, kind);
|
|
Attr = new (ctx) NonSendableAttr((NonSendableKind)kind);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Optimize_DECL_ATTR: {
|
|
unsigned kind;
|
|
serialization::decls_block::OptimizeDeclAttrLayout::readRecord(
|
|
scratch, kind);
|
|
Attr = new (ctx) OptimizeAttr((OptimizationMode)kind);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Exclusivity_DECL_ATTR: {
|
|
unsigned kind;
|
|
serialization::decls_block::ExclusivityDeclAttrLayout::readRecord(
|
|
scratch, kind);
|
|
Attr = new (ctx) ExclusivityAttr((ExclusivityAttr::Mode)kind);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Effects_DECL_ATTR: {
|
|
unsigned kind;
|
|
IdentifierID customStringID;
|
|
serialization::decls_block::EffectsDeclAttrLayout::
|
|
readRecord(scratch, kind, customStringID);
|
|
if (customStringID) {
|
|
assert((EffectsKind)kind == EffectsKind::Custom);
|
|
Attr = new (ctx) EffectsAttr(MF.getIdentifier(customStringID).str());
|
|
} else {
|
|
Attr = new (ctx) EffectsAttr((EffectsKind)kind);
|
|
}
|
|
break;
|
|
}
|
|
case decls_block::OriginallyDefinedIn_DECL_ATTR: {
|
|
bool isImplicit;
|
|
unsigned Platform;
|
|
DEF_VER_TUPLE_PIECES(MovedVer);
|
|
// Decode the record, pulling the version tuple information.
|
|
serialization::decls_block::OriginallyDefinedInDeclAttrLayout::readRecord(
|
|
scratch,
|
|
isImplicit,
|
|
LIST_VER_TUPLE_PIECES(MovedVer),
|
|
Platform);
|
|
llvm::VersionTuple MovedVer;
|
|
DECODE_VER_TUPLE(MovedVer)
|
|
|
|
auto ManglingModuleNameEnd = blobData.find('\0');
|
|
assert(ManglingModuleNameEnd != StringRef::npos);
|
|
auto ManglingModuleName = blobData.slice(0, ManglingModuleNameEnd);
|
|
|
|
blobData = blobData.slice(ManglingModuleNameEnd + 1, blobData.size());
|
|
|
|
auto LinkerModuleNameEnd = blobData.find('\0');
|
|
assert(LinkerModuleNameEnd != StringRef::npos);
|
|
auto LinkerModuleName = blobData.slice(0, LinkerModuleNameEnd);
|
|
|
|
ASSERT(!ManglingModuleName.empty());
|
|
ASSERT(!LinkerModuleName.empty());
|
|
|
|
Attr = new (ctx) OriginallyDefinedInAttr(SourceLoc(), SourceRange(),
|
|
ManglingModuleName,
|
|
LinkerModuleName,
|
|
(PlatformKind)Platform,
|
|
MovedVer,
|
|
isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Available_DECL_ATTR: {
|
|
auto attrOrError = readAvailable_DECL_ATTR(scratch, blobData);
|
|
if (!attrOrError)
|
|
return MF.diagnoseFatal(attrOrError.takeError());
|
|
|
|
Attr = attrOrError.get();
|
|
break;
|
|
}
|
|
|
|
case decls_block::ObjC_DECL_ATTR: {
|
|
bool isImplicit;
|
|
bool isImplicitName;
|
|
uint64_t numArgs;
|
|
ArrayRef<uint64_t> rawPieceIDs;
|
|
serialization::decls_block::ObjCDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, isImplicitName, numArgs, rawPieceIDs);
|
|
|
|
SmallVector<Identifier, 4> pieces;
|
|
for (auto pieceID : rawPieceIDs)
|
|
pieces.push_back(MF.getIdentifier(pieceID));
|
|
|
|
if (numArgs == 0)
|
|
Attr = ObjCAttr::create(ctx, std::nullopt, isImplicitName);
|
|
else
|
|
Attr = ObjCAttr::create(ctx, ObjCSelector(ctx, numArgs-1, pieces),
|
|
isImplicitName);
|
|
Attr->setImplicit(isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Specialize_DECL_ATTR: {
|
|
unsigned isPublic;
|
|
unsigned exported;
|
|
SpecializeAttr::SpecializationKind specializationKind;
|
|
unsigned specializationKindVal;
|
|
GenericSignatureID specializedSigID;
|
|
|
|
ArrayRef<uint64_t> rawTrailingIDs;
|
|
uint64_t numSPIGroups;
|
|
uint64_t numAvailabilityAttrs;
|
|
DeclID targetFunID;
|
|
|
|
serialization::decls_block::SpecializeDeclAttrLayout::readRecord(
|
|
scratch, isPublic, exported, specializationKindVal, specializedSigID,
|
|
targetFunID, numSPIGroups, numAvailabilityAttrs, rawTrailingIDs);
|
|
|
|
specializationKind = specializationKindVal
|
|
? SpecializeAttr::SpecializationKind::Partial
|
|
: SpecializeAttr::SpecializationKind::Full;
|
|
|
|
auto specializedSig = MF.getGenericSignature(specializedSigID);
|
|
|
|
// Take `numSPIGroups` trailing identifiers for the SPI groups.
|
|
SmallVector<Identifier, 4> spis;
|
|
for (auto id : rawTrailingIDs.take_front(numSPIGroups))
|
|
spis.push_back(MF.getIdentifier(id));
|
|
|
|
// Take the rest for type-erased parameters.
|
|
SmallVector<Type, 4> typeErasedParams;
|
|
for (auto id : rawTrailingIDs.drop_front(numSPIGroups))
|
|
typeErasedParams.push_back(MF.getType(id));
|
|
|
|
// Read availability attrs.
|
|
SmallVector<AvailableAttr *, 4> availabilityAttrs;
|
|
while (numAvailabilityAttrs) {
|
|
// Prepare to read the next record.
|
|
restoreOffset.cancel();
|
|
scratch.clear();
|
|
|
|
// TODO: deserialize them.
|
|
BCOffsetRAII restoreOffset2(MF.DeclTypeCursor);
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance());
|
|
if (entry.Kind != llvm::BitstreamEntry::Record) {
|
|
// We don't know how to serialize decls represented by sub-blocks.
|
|
return MF.diagnoseFatal();
|
|
}
|
|
unsigned recordID = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != decls_block::Available_DECL_ATTR) {
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
auto attr = readAvailable_DECL_ATTR(scratch, blobData);
|
|
if (!attr)
|
|
return MF.diagnoseFatal(attr.takeError());
|
|
|
|
availabilityAttrs.push_back(attr.get());
|
|
restoreOffset2.cancel();
|
|
--numAvailabilityAttrs;
|
|
}
|
|
|
|
// Read target function DeclNameRef, if present.
|
|
DeclNameRef targetFunName = deserializeDeclNameRefIfPresent();
|
|
if (isPublic)
|
|
Attr = SpecializedAttr::create(ctx, exported != 0, specializationKind,
|
|
spis, availabilityAttrs, typeErasedParams,
|
|
specializedSig, targetFunName, &MF,
|
|
targetFunID);
|
|
else
|
|
Attr = SpecializeAttr::create(ctx, exported != 0, specializationKind,
|
|
spis, availabilityAttrs, typeErasedParams,
|
|
specializedSig, targetFunName, &MF,
|
|
targetFunID);
|
|
break;
|
|
}
|
|
|
|
case decls_block::StorageRestrictions_DECL_ATTR: {
|
|
unsigned numInitializesProperties;
|
|
ArrayRef<uint64_t> rawPropertyIDs;
|
|
serialization::decls_block::StorageRestrictionsDeclAttrLayout::
|
|
readRecord(scratch, numInitializesProperties, rawPropertyIDs);
|
|
|
|
SmallVector<Identifier> initializes;
|
|
SmallVector<Identifier> accesses;
|
|
|
|
for (unsigned i = 0, n = rawPropertyIDs.size(); i != n; ++i) {
|
|
auto propertyName = MF.getIdentifier(rawPropertyIDs[i]);
|
|
|
|
if (i < numInitializesProperties) {
|
|
initializes.push_back(propertyName);
|
|
} else {
|
|
accesses.push_back(propertyName);
|
|
}
|
|
}
|
|
|
|
Attr = StorageRestrictionsAttr::create(ctx, SourceLoc(), SourceRange(),
|
|
initializes, accesses);
|
|
break;
|
|
}
|
|
|
|
case decls_block::DynamicReplacement_DECL_ATTR: {
|
|
bool isImplicit;
|
|
DeclID replacedFunID;
|
|
serialization::decls_block::DynamicReplacementDeclAttrLayout::
|
|
readRecord(scratch, isImplicit, replacedFunID);
|
|
|
|
DeclNameRef replacedFunName = deserializeDeclNameRefIfPresent();
|
|
|
|
assert(!isImplicit && "Need to update for implicit");
|
|
Attr = DynamicReplacementAttr::create(ctx, replacedFunName, &MF,
|
|
replacedFunID);
|
|
break;
|
|
}
|
|
|
|
case decls_block::TypeEraser_DECL_ATTR: {
|
|
bool isImplicit;
|
|
TypeID typeEraserID;
|
|
serialization::decls_block::TypeEraserDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, typeEraserID);
|
|
|
|
assert(!isImplicit);
|
|
Attr = TypeEraserAttr::create(ctx, &MF, typeEraserID);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Custom_DECL_ATTR: {
|
|
// Deserialize the custom attributes after the attached decl,
|
|
// skip for now.
|
|
customAttrOffsets.push_back(attrOffset);
|
|
skipAttr = true;
|
|
break;
|
|
}
|
|
|
|
case decls_block::ProjectedValueProperty_DECL_ATTR: {
|
|
bool isImplicit;
|
|
IdentifierID nameID;
|
|
serialization::decls_block::ProjectedValuePropertyDeclAttrLayout
|
|
::readRecord(scratch, isImplicit, nameID);
|
|
|
|
auto name = MF.getIdentifier(nameID);
|
|
Attr = new (ctx) ProjectedValuePropertyAttr(
|
|
name, SourceLoc(), SourceRange(), isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Differentiable_DECL_ATTR: {
|
|
bool isImplicit;
|
|
uint64_t rawDiffKind;
|
|
GenericSignatureID derivativeGenSigId;
|
|
ArrayRef<uint64_t> parameters;
|
|
|
|
serialization::decls_block::DifferentiableDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, rawDiffKind, derivativeGenSigId,
|
|
parameters);
|
|
|
|
auto diffKind = getActualDifferentiabilityKind(rawDiffKind);
|
|
if (!diffKind)
|
|
return MF.diagnoseFatal();
|
|
auto derivativeGenSig = MF.getGenericSignature(derivativeGenSigId);
|
|
llvm::SmallBitVector parametersBitVector(parameters.size());
|
|
for (unsigned i : indices(parameters))
|
|
parametersBitVector[i] = parameters[i];
|
|
auto *indices = IndexSubset::get(ctx, parametersBitVector);
|
|
auto *diffAttr = DifferentiableAttr::create(
|
|
ctx, isImplicit, SourceLoc(), SourceRange(), *diffKind,
|
|
/*parsedParameters*/ {}, /*trailingWhereClause*/ nullptr);
|
|
|
|
// Cache parameter indices so that they can set later.
|
|
// `DifferentiableAttr::setParameterIndices` cannot be called here
|
|
// because it requires `DifferentiableAttr::setOriginalDeclaration` to
|
|
// be called first. `DifferentiableAttr::setOriginalDeclaration` cannot
|
|
// be called here because the original declaration is not accessible in
|
|
// this function (`DeclDeserializer::deserializeDeclCommon`).
|
|
diffAttrParamIndicesMap[diffAttr] = indices;
|
|
diffAttr->setDerivativeGenericSignature(derivativeGenSig);
|
|
Attr = diffAttr;
|
|
break;
|
|
}
|
|
|
|
case decls_block::Derivative_DECL_ATTR: {
|
|
bool isImplicit;
|
|
bool hasAccessorKind;
|
|
uint64_t rawAccessorKind;
|
|
DeclID origDeclId;
|
|
uint64_t rawDerivativeKind;
|
|
ArrayRef<uint64_t> parameters;
|
|
|
|
serialization::decls_block::DerivativeDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, hasAccessorKind, rawAccessorKind,
|
|
origDeclId, rawDerivativeKind, parameters);
|
|
|
|
std::optional<AccessorKind> accessorKind = std::nullopt;
|
|
if (hasAccessorKind) {
|
|
auto maybeAccessorKind = getActualAccessorKind(rawAccessorKind);
|
|
if (!maybeAccessorKind)
|
|
return MF.diagnoseFatal();
|
|
accessorKind = *maybeAccessorKind;
|
|
}
|
|
|
|
auto derivativeKind =
|
|
getActualAutoDiffDerivativeFunctionKind(rawDerivativeKind);
|
|
if (!derivativeKind)
|
|
return MF.diagnoseFatal();
|
|
llvm::SmallBitVector parametersBitVector(parameters.size());
|
|
for (unsigned i : indices(parameters))
|
|
parametersBitVector[i] = parameters[i];
|
|
auto *indices = IndexSubset::get(ctx, parametersBitVector);
|
|
|
|
auto origName = deserializeDeclNameRefIfPresent();
|
|
DeclNameRefWithLoc origNameWithLoc{origName, DeclNameLoc(),
|
|
accessorKind};
|
|
|
|
auto *derivativeAttr =
|
|
DerivativeAttr::create(ctx, isImplicit, SourceLoc(), SourceRange(),
|
|
/*baseType*/ nullptr, origNameWithLoc,
|
|
indices);
|
|
derivativeAttr->setOriginalFunctionResolver(&MF, origDeclId);
|
|
derivativeAttr->setDerivativeKind(*derivativeKind);
|
|
Attr = derivativeAttr;
|
|
break;
|
|
}
|
|
|
|
case decls_block::Transpose_DECL_ATTR: {
|
|
bool isImplicit;
|
|
DeclID origDeclId;
|
|
ArrayRef<uint64_t> parameters;
|
|
|
|
serialization::decls_block::TransposeDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, origDeclId, parameters);
|
|
|
|
auto *origDecl = cast<AbstractFunctionDecl>(MF.getDecl(origDeclId));
|
|
llvm::SmallBitVector parametersBitVector(parameters.size());
|
|
for (unsigned i : indices(parameters))
|
|
parametersBitVector[i] = parameters[i];
|
|
auto *indices = IndexSubset::get(ctx, parametersBitVector);
|
|
|
|
auto origNameRef = deserializeDeclNameRefIfPresent();
|
|
DeclNameRefWithLoc origName{origNameRef, DeclNameLoc(), std::nullopt};
|
|
|
|
auto *transposeAttr =
|
|
TransposeAttr::create(ctx, isImplicit, SourceLoc(), SourceRange(),
|
|
/*baseTypeRepr*/ nullptr, origName, indices);
|
|
transposeAttr->setOriginalFunction(origDecl);
|
|
Attr = transposeAttr;
|
|
break;
|
|
}
|
|
|
|
case decls_block::SPIAccessControl_DECL_ATTR: {
|
|
ArrayRef<uint64_t> spiIds;
|
|
serialization::decls_block::SPIAccessControlDeclAttrLayout::readRecord(
|
|
scratch, spiIds);
|
|
|
|
SmallVector<Identifier, 4> spis;
|
|
for (auto id : spiIds)
|
|
spis.push_back(MF.getIdentifier(id));
|
|
|
|
Attr = SPIAccessControlAttr::create(ctx, SourceLoc(),
|
|
SourceRange(), spis);
|
|
break;
|
|
}
|
|
|
|
case decls_block::UnavailableFromAsync_DECL_ATTR: {
|
|
bool isImplicit;
|
|
serialization::decls_block::UnavailableFromAsyncDeclAttrLayout::
|
|
readRecord(scratch, isImplicit);
|
|
Attr = new (ctx) UnavailableFromAsyncAttr(blobData, isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::BackDeployed_DECL_ATTR: {
|
|
bool isImplicit;
|
|
unsigned Platform;
|
|
DEF_VER_TUPLE_PIECES(Version);
|
|
serialization::decls_block::BackDeployedDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, LIST_VER_TUPLE_PIECES(Version), Platform);
|
|
llvm::VersionTuple Version;
|
|
DECODE_VER_TUPLE(Version)
|
|
Attr = new (ctx)
|
|
BackDeployedAttr(SourceLoc(), SourceRange(), (PlatformKind)Platform,
|
|
Version, isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Expose_DECL_ATTR: {
|
|
unsigned kind;
|
|
bool isImplicit;
|
|
serialization::decls_block::ExposeDeclAttrLayout::readRecord(
|
|
scratch, kind, isImplicit);
|
|
Attr = new (ctx) ExposeAttr(blobData, (ExposureKind)kind, isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Extern_DECL_ATTR: {
|
|
unsigned rawKind;
|
|
bool isImplicit;
|
|
unsigned moduleNameSize, declNameSize;
|
|
serialization::decls_block::ExternDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, rawKind, moduleNameSize, declNameSize);
|
|
|
|
ExternKind kind = (ExternKind)rawKind;
|
|
std::optional<StringRef> moduleName, declName;
|
|
|
|
switch (kind) {
|
|
case ExternKind::C: {
|
|
// Empty C name is rejected by typecheck, so serialized zero-length
|
|
// name is treated as no decl name.
|
|
if (declNameSize > 0)
|
|
declName = blobData.substr(0, declNameSize);
|
|
break;
|
|
}
|
|
case ExternKind::Wasm: {
|
|
moduleName = blobData.substr(0, moduleNameSize);
|
|
blobData = blobData.substr(moduleNameSize);
|
|
declName = blobData.substr(0, declNameSize);
|
|
break;
|
|
}
|
|
}
|
|
Attr = new (ctx) ExternAttr(moduleName, declName, (ExternKind)rawKind, isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Documentation_DECL_ATTR: {
|
|
bool isImplicit;
|
|
uint64_t CategoryID;
|
|
bool hasVisibility;
|
|
uint8_t visibilityID;
|
|
serialization::decls_block::DocumentationDeclAttrLayout::readRecord(
|
|
scratch, isImplicit, CategoryID, hasVisibility, visibilityID);
|
|
StringRef CategoryText = MF.getIdentifierText(CategoryID);
|
|
std::optional<swift::AccessLevel> realVisibility = std::nullopt;
|
|
if (hasVisibility)
|
|
realVisibility = getActualAccessLevel(visibilityID);
|
|
Attr = new (ctx) DocumentationAttr(CategoryText, realVisibility, isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::ObjCImplementation_DECL_ATTR: {
|
|
bool isImplicit;
|
|
bool isCategoryNameInvalid;
|
|
bool isEarlyAdopter;
|
|
uint64_t categoryNameID;
|
|
serialization::decls_block::ObjCImplementationDeclAttrLayout::
|
|
readRecord(scratch, isImplicit, isCategoryNameInvalid,
|
|
isEarlyAdopter, categoryNameID);
|
|
Identifier categoryName = MF.getIdentifier(categoryNameID);
|
|
Attr = new (ctx) ObjCImplementationAttr(categoryName, SourceLoc(),
|
|
SourceRange(), isEarlyAdopter,
|
|
isImplicit,
|
|
isCategoryNameInvalid);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Nonisolated_DECL_ATTR: {
|
|
unsigned modifier;
|
|
bool isImplicit{};
|
|
serialization::decls_block::NonisolatedDeclAttrLayout::readRecord(
|
|
scratch, modifier, isImplicit);
|
|
Attr = new (ctx) NonisolatedAttr(
|
|
{}, {}, static_cast<NonIsolatedModifier>(modifier), isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::InheritActorContext_DECL_ATTR: {
|
|
unsigned modifier;
|
|
bool isImplicit{};
|
|
serialization::decls_block::InheritActorContextDeclAttrLayout::
|
|
readRecord(scratch, modifier, isImplicit);
|
|
Attr = new (ctx) InheritActorContextAttr(
|
|
{}, {}, static_cast<InheritActorContextModifier>(modifier),
|
|
isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::MacroRole_DECL_ATTR: {
|
|
bool isImplicit;
|
|
uint8_t rawMacroSyntax;
|
|
uint8_t rawMacroRole;
|
|
uint64_t numNames;
|
|
uint64_t numConformances;
|
|
ArrayRef<uint64_t> introducedDeclNames;
|
|
serialization::decls_block::MacroRoleDeclAttrLayout::
|
|
readRecord(scratch, isImplicit, rawMacroSyntax, rawMacroRole,
|
|
numNames, numConformances, introducedDeclNames);
|
|
auto role = *getActualMacroRole(rawMacroRole);
|
|
SmallVector<MacroIntroducedDeclName, 1> names;
|
|
unsigned nameIdx = 0;
|
|
while (nameIdx < numNames) {
|
|
auto kind = getActualMacroIntroducedDeclNameKind(
|
|
(uint8_t)introducedDeclNames[nameIdx++]);
|
|
auto baseName =
|
|
MF.getDeclBaseName(IdentifierID(introducedDeclNames[nameIdx++]));
|
|
|
|
unsigned numArgs = introducedDeclNames[nameIdx++];
|
|
if (numArgs == 0) {
|
|
names.push_back(MacroIntroducedDeclName(*kind, baseName));
|
|
continue;
|
|
}
|
|
|
|
SmallVector<Identifier, 2> argLabels;
|
|
for (unsigned i : range(0, numArgs - 1)) {
|
|
(void)i;
|
|
argLabels.push_back(
|
|
MF.getDeclBaseName(
|
|
IdentifierID(introducedDeclNames[nameIdx++]))
|
|
.getIdentifier());
|
|
}
|
|
|
|
DeclName name(ctx, baseName, argLabels);
|
|
names.push_back(MacroIntroducedDeclName(*kind, name));
|
|
}
|
|
|
|
introducedDeclNames = introducedDeclNames.slice(numNames);
|
|
SmallVector<Expr *, 1> conformances;
|
|
for (TypeID conformanceID : introducedDeclNames) {
|
|
auto conformance = MF.getTypeChecked(conformanceID);
|
|
if (!conformance) {
|
|
return conformance.takeError();
|
|
}
|
|
|
|
conformances.push_back(
|
|
TypeExpr::createImplicit(conformance.get(), ctx));
|
|
}
|
|
|
|
Attr = MacroRoleAttr::create(
|
|
ctx, SourceLoc(), SourceRange(),
|
|
static_cast<MacroSyntax>(rawMacroSyntax), SourceLoc(), role, names,
|
|
conformances, SourceLoc(), isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::Section_DECL_ATTR: {
|
|
bool isImplicit;
|
|
serialization::decls_block::SectionDeclAttrLayout::readRecord(
|
|
scratch, isImplicit);
|
|
Attr = new (ctx) SectionAttr(blobData, isImplicit);
|
|
break;
|
|
}
|
|
|
|
case decls_block::RawLayout_DECL_ATTR: {
|
|
bool isImplicit;
|
|
TypeID typeID;
|
|
TypeID countID;
|
|
uint32_t rawSize;
|
|
uint8_t rawAlign;
|
|
bool movesAsLike;
|
|
serialization::decls_block::RawLayoutDeclAttrLayout::
|
|
readRecord(scratch, isImplicit, typeID, countID, rawSize, rawAlign,
|
|
movesAsLike);
|
|
|
|
if (typeID) {
|
|
auto type = MF.getTypeChecked(typeID);
|
|
if (!type) {
|
|
return type.takeError();
|
|
}
|
|
auto typeRepr = new (ctx) FixedTypeRepr(type.get(), SourceLoc());
|
|
if (!countID) {
|
|
Attr = new (ctx) RawLayoutAttr(typeRepr,
|
|
movesAsLike,
|
|
SourceLoc(),
|
|
SourceRange());
|
|
break;
|
|
} else {
|
|
auto count = MF.getTypeChecked(countID);
|
|
if (!count) {
|
|
return count.takeError();
|
|
}
|
|
auto countRepr = new (ctx) FixedTypeRepr(count.get(), SourceLoc());
|
|
|
|
Attr = new (ctx) RawLayoutAttr(typeRepr, countRepr, movesAsLike,
|
|
SourceLoc(),
|
|
SourceRange());
|
|
break;
|
|
}
|
|
}
|
|
|
|
Attr = new (ctx) RawLayoutAttr(rawSize, rawAlign,
|
|
SourceLoc(), SourceRange());
|
|
break;
|
|
}
|
|
|
|
case decls_block::Nonexhaustive_DECL_ATTR: {
|
|
unsigned mode;
|
|
serialization::decls_block::NonexhaustiveDeclAttrLayout::readRecord(
|
|
scratch, mode);
|
|
Attr = new (ctx) NonexhaustiveAttr((NonexhaustiveMode)mode);
|
|
break;
|
|
}
|
|
|
|
#define SIMPLE_DECL_ATTR(NAME, CLASS, ...) \
|
|
case decls_block::CLASS##_DECL_ATTR: { \
|
|
bool isImplicit; \
|
|
serialization::decls_block::CLASS##DeclAttrLayout::readRecord( \
|
|
scratch, isImplicit); \
|
|
Attr = new (ctx) CLASS##Attr(isImplicit); \
|
|
break; \
|
|
}
|
|
#include "swift/AST/DeclAttr.def"
|
|
|
|
default:
|
|
// We don't know how to deserialize this kind of attribute.
|
|
MF.fatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
}
|
|
|
|
if (!skipAttr) {
|
|
if (!Attr)
|
|
return llvm::Error::success();
|
|
|
|
AddAttribute(Attr);
|
|
}
|
|
|
|
} else if (recordID == decls_block::PRIVATE_DISCRIMINATOR) {
|
|
IdentifierID discriminatorID;
|
|
decls_block::PrivateDiscriminatorLayout::readRecord(scratch,
|
|
discriminatorID);
|
|
privateDiscriminator = MF.getIdentifier(discriminatorID);
|
|
|
|
} else if (recordID == decls_block::LOCAL_DISCRIMINATOR) {
|
|
unsigned discriminator;
|
|
decls_block::LocalDiscriminatorLayout::readRecord(scratch, discriminator);
|
|
localDiscriminator = discriminator;
|
|
} else if (recordID == decls_block::FILENAME_FOR_PRIVATE) {
|
|
IdentifierID filenameID;
|
|
decls_block::FilenameForPrivateLayout::readRecord(scratch, filenameID);
|
|
filenameForPrivate = MF.getIdentifierText(filenameID);
|
|
} else if (recordID == decls_block::DESERIALIZATION_SAFETY) {
|
|
IdentifierID declID;
|
|
decls_block::DeserializationSafetyLayout::readRecord(scratch, declID);
|
|
|
|
if (MF.getResilienceStrategy() == ResilienceStrategy::Resilient &&
|
|
MF.getContext().LangOpts.EnableDeserializationSafety) {
|
|
auto name = MF.getIdentifier(declID);
|
|
LLVM_DEBUG(llvm::dbgs() << "Skipping unsafe deserialization: '"
|
|
<< name << "'\n");
|
|
return llvm::make_error<UnsafeDeserializationError>(name);
|
|
}
|
|
} else {
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
// Prepare to read the next record.
|
|
restoreOffset.cancel();
|
|
scratch.clear();
|
|
}
|
|
}
|
|
|
|
/// Complete attributes that contain recursive references to the decl being
|
|
/// deserialized or to other decls. This method is called after the decl is
|
|
/// created and stored into the \c ModuleFile::Decls table, so any cycles
|
|
/// between mutually-referencing decls will be broken.
|
|
///
|
|
/// Attributes handled here include:
|
|
///
|
|
/// \li \c \@abi
|
|
llvm::Error DeclDeserializer::finishRecursiveAttrs() {
|
|
// @abi
|
|
if (unresolvedABIAttr) {
|
|
auto abiDeclOrError = MF.getDeclChecked(unresolvedABIAttr->second);
|
|
if (!abiDeclOrError)
|
|
return abiDeclOrError.takeError();
|
|
unresolvedABIAttr->first->abiDecl = abiDeclOrError.get();
|
|
}
|
|
if (ABIDeclCounterpartID != 0) {
|
|
// This decl is the `abiDecl` of an `ABIAttr`. Force the decl that `ABIAttr`
|
|
// belongs to so that `attachToDecl()` will be called.
|
|
auto counterpartOrError = MF.getDeclChecked(ABIDeclCounterpartID);
|
|
if (!counterpartOrError)
|
|
return counterpartOrError.takeError();
|
|
(void)counterpartOrError.get();
|
|
}
|
|
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
Expected<Decl *>
|
|
DeclDeserializer::getDeclCheckedImpl(
|
|
llvm::function_ref<bool(DeclAttributes)> matchAttributes) {
|
|
|
|
auto commonError = deserializeDeclCommon();
|
|
if (commonError)
|
|
return std::move(commonError);
|
|
|
|
if (matchAttributes) {
|
|
// Deserialize the full decl only if matchAttributes finds a match.
|
|
DeclAttributes attrs = DeclAttributes();
|
|
attrs.setRawAttributeChain(DAttrs);
|
|
if (!matchAttributes(attrs))
|
|
return llvm::make_error<DeclAttributesDidNotMatch>();
|
|
}
|
|
|
|
if (auto s = ctx.Stats)
|
|
++s->getFrontendCounters().NumDeclsDeserialized;
|
|
|
|
// FIXME: @_dynamicReplacement(for:) includes a reference to another decl,
|
|
// usually in the same type, and that can result in this decl being
|
|
// re-entrantly deserialized. If that happens, don't fail here.
|
|
if (declOrOffset.isComplete())
|
|
return declOrOffset;
|
|
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance());
|
|
if (entry.Kind != llvm::BitstreamEntry::Record) {
|
|
// We don't know how to serialize decls represented by sub-blocks.
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
SmallVector<uint64_t, 64> scratch;
|
|
StringRef blobData;
|
|
unsigned recordID = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
|
|
PrettyDeclDeserialization stackTraceEntry(
|
|
&MF, declOrOffset, static_cast<decls_block::RecordKind>(recordID));
|
|
|
|
switch (recordID) {
|
|
#define CASE(RECORD_NAME) \
|
|
case decls_block::RECORD_NAME##Layout::Code: {\
|
|
auto declOrError = deserialize##RECORD_NAME(scratch, blobData); \
|
|
if (!declOrError) \
|
|
return declOrError; \
|
|
declOrOffset = declOrError.get(); \
|
|
if (auto finishError = finishRecursiveAttrs()) \
|
|
return finishError; \
|
|
break; \
|
|
}
|
|
|
|
CASE(TypeAlias)
|
|
CASE(GenericTypeParamDecl)
|
|
CASE(AssociatedTypeDecl)
|
|
CASE(Struct)
|
|
CASE(Constructor)
|
|
CASE(Var)
|
|
CASE(Param)
|
|
CASE(Func)
|
|
CASE(OpaqueType)
|
|
CASE(Accessor)
|
|
CASE(PatternBinding)
|
|
CASE(Protocol)
|
|
CASE(PrefixOperator)
|
|
CASE(PostfixOperator)
|
|
CASE(InfixOperator)
|
|
CASE(PrecedenceGroup)
|
|
CASE(Class)
|
|
CASE(Enum)
|
|
CASE(EnumElement)
|
|
CASE(Subscript)
|
|
CASE(Extension)
|
|
CASE(Destructor)
|
|
CASE(Macro)
|
|
#undef CASE
|
|
|
|
case decls_block::XREF: {
|
|
assert(DAttrs == nullptr);
|
|
ModuleID baseModuleID;
|
|
uint32_t pathLen;
|
|
decls_block::XRefLayout::readRecord(scratch, baseModuleID, pathLen);
|
|
auto resolved = MF.resolveCrossReference(baseModuleID, pathLen);
|
|
if (!resolved)
|
|
return resolved;
|
|
declOrOffset = resolved.get();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// We don't know how to deserialize this kind of decl.
|
|
MF.fatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
}
|
|
|
|
auto attrError = deserializeCustomAttrs();
|
|
if (attrError)
|
|
return std::move(attrError);
|
|
return declOrOffset;
|
|
}
|
|
|
|
/// Translate from the Serialization function type repr enum values to the AST
|
|
/// strongly-typed enum.
|
|
///
|
|
/// The former is guaranteed to be stable, but may not reflect this version of
|
|
/// the AST.
|
|
static std::optional<swift::FunctionType::Representation>
|
|
getActualFunctionTypeRepresentation(uint8_t rep) {
|
|
switch (rep) {
|
|
#define CASE(THE_CC) \
|
|
case (uint8_t)serialization::FunctionTypeRepresentation::THE_CC: \
|
|
return swift::FunctionType::Representation::THE_CC;
|
|
CASE(Swift)
|
|
CASE(Block)
|
|
CASE(Thin)
|
|
CASE(CFunctionPointer)
|
|
#undef CASE
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
/// Translate from the Serialization function type repr enum values to the AST
|
|
/// strongly-typed enum.
|
|
///
|
|
/// The former is guaranteed to be stable, but may not reflect this version of
|
|
/// the AST.
|
|
static std::optional<swift::SILFunctionType::Representation>
|
|
getActualSILFunctionTypeRepresentation(uint8_t rep) {
|
|
switch (rep) {
|
|
#define CASE(THE_CC) \
|
|
case (uint8_t)serialization::SILFunctionTypeRepresentation::THE_CC: \
|
|
return swift::SILFunctionType::Representation::THE_CC;
|
|
CASE(Thick)
|
|
CASE(Block)
|
|
CASE(Thin)
|
|
CASE(CFunctionPointer)
|
|
CASE(Method)
|
|
CASE(ObjCMethod)
|
|
CASE(WitnessMethod)
|
|
CASE(CXXMethod)
|
|
CASE(KeyPathAccessorGetter)
|
|
CASE(KeyPathAccessorSetter)
|
|
CASE(KeyPathAccessorEquals)
|
|
CASE(KeyPathAccessorHash)
|
|
#undef CASE
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
/// Translate from the Serialization coroutine kind enum values to the AST
|
|
/// strongly-typed enum.
|
|
///
|
|
/// The former is guaranteed to be stable, but may not reflect this version of
|
|
/// the AST.
|
|
static std::optional<swift::SILCoroutineKind>
|
|
getActualSILCoroutineKind(uint8_t rep) {
|
|
switch (rep) {
|
|
#define CASE(KIND) \
|
|
case (uint8_t)serialization::SILCoroutineKind::KIND: \
|
|
return swift::SILCoroutineKind::KIND;
|
|
CASE(None)
|
|
CASE(YieldOnce)
|
|
CASE(YieldOnce2)
|
|
CASE(YieldMany)
|
|
#undef CASE
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
/// Translate from the serialization ReferenceOwnership enumerators, which are
|
|
/// guaranteed to be stable, to the AST ones.
|
|
static std::optional<swift::ReferenceOwnership>
|
|
getActualReferenceOwnership(serialization::ReferenceOwnership raw) {
|
|
switch (raw) {
|
|
case serialization::ReferenceOwnership::Strong:
|
|
return swift::ReferenceOwnership::Strong;
|
|
#define REF_STORAGE(Name, ...) \
|
|
case serialization::ReferenceOwnership::Name: \
|
|
return swift::ReferenceOwnership::Name;
|
|
#include "swift/AST/ReferenceStorage.def"
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
/// Translate from the serialization ParameterConvention enumerators,
|
|
/// which are guaranteed to be stable, to the AST ones.
|
|
static std::optional<swift::ParameterConvention>
|
|
getActualParameterConvention(uint8_t raw) {
|
|
switch (serialization::ParameterConvention(raw)) {
|
|
#define CASE(ID) \
|
|
case serialization::ParameterConvention::ID: \
|
|
return swift::ParameterConvention::ID;
|
|
CASE(Indirect_In)
|
|
CASE(Indirect_Inout)
|
|
CASE(Indirect_InoutAliasable)
|
|
CASE(Indirect_In_CXX)
|
|
CASE(Indirect_In_Guaranteed)
|
|
case serialization::ParameterConvention::Indirect_In_Constant: \
|
|
return swift::ParameterConvention::Indirect_In;
|
|
CASE(Direct_Owned)
|
|
CASE(Direct_Unowned)
|
|
CASE(Direct_Guaranteed)
|
|
CASE(Pack_Inout)
|
|
CASE(Pack_Guaranteed)
|
|
CASE(Pack_Owned)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
/// Translate from the serialization SILParameterInfoFlags enumerators,
|
|
/// which are guaranteed to be stable, to the AST ones.
|
|
static std::optional<SILParameterInfo::Options>
|
|
getActualSILParameterOptions(uint8_t raw) {
|
|
auto options = serialization::SILParameterInfoOptions(raw);
|
|
SILParameterInfo::Options result;
|
|
|
|
// Every time we resolve an option, remove it from options so we can make sure
|
|
// that options is empty at the end and return none.
|
|
if (options.contains(
|
|
serialization::SILParameterInfoFlags::NotDifferentiable)) {
|
|
options -= serialization::SILParameterInfoFlags::NotDifferentiable;
|
|
result |= SILParameterInfo::NotDifferentiable;
|
|
}
|
|
|
|
if (options.contains(serialization::SILParameterInfoFlags::Isolated)) {
|
|
options -= serialization::SILParameterInfoFlags::Isolated;
|
|
result |= SILParameterInfo::Isolated;
|
|
}
|
|
|
|
if (options.contains(serialization::SILParameterInfoFlags::Sending)) {
|
|
options -= serialization::SILParameterInfoFlags::Sending;
|
|
result |= SILParameterInfo::Sending;
|
|
}
|
|
|
|
if (options.contains(serialization::SILParameterInfoFlags::ImplicitLeading)) {
|
|
options -= serialization::SILParameterInfoFlags::ImplicitLeading;
|
|
result |= SILParameterInfo::ImplicitLeading;
|
|
}
|
|
|
|
if (options.contains(serialization::SILParameterInfoFlags::Const)) {
|
|
options -= serialization::SILParameterInfoFlags::Const;
|
|
result |= SILParameterInfo::Const;
|
|
}
|
|
|
|
// Check if we have any remaining options and return none if we do. We found
|
|
// some option that we did not understand.
|
|
if (bool(options)) {
|
|
return {};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Translate from the serialization ResultConvention enumerators,
|
|
/// which are guaranteed to be stable, to the AST ones.
|
|
static std::optional<swift::ResultConvention>
|
|
getActualResultConvention(uint8_t raw) {
|
|
switch (serialization::ResultConvention(raw)) {
|
|
#define CASE(ID) \
|
|
case serialization::ResultConvention::ID: return swift::ResultConvention::ID;
|
|
CASE(Indirect)
|
|
CASE(Owned)
|
|
CASE(Unowned)
|
|
CASE(UnownedInnerPointer)
|
|
CASE(Autoreleased)
|
|
CASE(Pack)
|
|
CASE(GuaranteedAddress)
|
|
CASE(Guaranteed)
|
|
CASE(Inout)
|
|
#undef CASE
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
/// Translate from the serialization SILResultInfoFlags enumerators,
|
|
/// which are guaranteed to be stable, to the AST ones.
|
|
///
|
|
/// If we find a flag that we did not know, return none.
|
|
static std::optional<SILResultInfo::Options>
|
|
getActualSILResultOptions(uint8_t raw) {
|
|
auto options = serialization::SILResultInfoOptions(raw);
|
|
SILResultInfo::Options result;
|
|
|
|
// Every time we resolve an option, remove it from options so we can make sure
|
|
// that options is empty at the end and return none.
|
|
if (options.contains(serialization::SILResultInfoFlags::NotDifferentiable)) {
|
|
options -= serialization::SILResultInfoFlags::NotDifferentiable;
|
|
result |= SILResultInfo::NotDifferentiable;
|
|
}
|
|
|
|
if (options.contains(serialization::SILResultInfoFlags::IsSending)) {
|
|
options -= serialization::SILResultInfoFlags::IsSending;
|
|
result |= SILResultInfo::IsSending;
|
|
}
|
|
|
|
// Check if we have any remaining options and return none if we do. We found
|
|
// some option that we did not understand.
|
|
if (bool(options)) {
|
|
return {};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Type ModuleFile::getType(TypeID TID) {
|
|
Expected<Type> deserialized = getTypeChecked(TID);
|
|
if (!deserialized) {
|
|
fatal(deserialized.takeError());
|
|
}
|
|
return deserialized.get();
|
|
}
|
|
|
|
namespace swift {
|
|
namespace serialization {
|
|
namespace decls_block {
|
|
|
|
#define DESERIALIZE_TYPE(TYPE_ID) \
|
|
detail::TypeRecordDispatch<detail::TypeRecords::TYPE_ID>::deserialize
|
|
|
|
Expected<Type>
|
|
DESERIALIZE_TYPE(BUILTIN_ALIAS_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
DeclID underlyingID;
|
|
TypeID canonicalTypeID;
|
|
decls_block::BuiltinAliasTypeLayout::readRecord(scratch, underlyingID,
|
|
canonicalTypeID);
|
|
auto aliasOrError = MF.getDeclChecked(underlyingID);
|
|
if (!aliasOrError)
|
|
return aliasOrError.takeError();
|
|
auto alias = dyn_cast<TypeAliasDecl>(aliasOrError.get());
|
|
|
|
if (MF.getContext().LangOpts.EnableDeserializationRecovery) {
|
|
Expected<Type> expectedType = MF.getTypeChecked(canonicalTypeID);
|
|
if (!expectedType)
|
|
return expectedType.takeError();
|
|
if (expectedType.get()) {
|
|
if (!alias ||
|
|
!alias->getDeclaredInterfaceType()->isEqual(expectedType.get())) {
|
|
// Fall back to the canonical type.
|
|
return expectedType.get();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Look through compatibility aliases that are now unavailable.
|
|
if (alias->isUnavailable() && alias->isCompatibilityAlias()) {
|
|
return alias->getUnderlyingType();
|
|
}
|
|
|
|
return alias->getDeclaredInterfaceType();
|
|
}
|
|
|
|
Expected<Type>
|
|
DESERIALIZE_TYPE(BUILTIN_FIXED_ARRAY_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData)
|
|
{
|
|
TypeID sizeID;
|
|
TypeID elementTypeID;
|
|
decls_block::BuiltinFixedArrayTypeLayout::readRecord(scratch, sizeID,
|
|
elementTypeID);
|
|
|
|
|
|
auto sizeOrError = MF.getTypeChecked(sizeID);
|
|
if (!sizeOrError) {
|
|
return sizeOrError.takeError();
|
|
}
|
|
auto size = sizeOrError.get()->getCanonicalType();
|
|
|
|
auto elementTypeOrError = MF.getTypeChecked(elementTypeID);
|
|
if (!elementTypeOrError) {
|
|
return elementTypeOrError.takeError();
|
|
}
|
|
auto elementType = elementTypeOrError.get()->getCanonicalType();
|
|
|
|
return BuiltinFixedArrayType::get(size, elementType);
|
|
}
|
|
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(NAME_ALIAS_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
DeclID typealiasID;
|
|
TypeID parentTypeID;
|
|
TypeID underlyingTypeID;
|
|
TypeID substitutedTypeID;
|
|
ArrayRef<uint64_t> rawArgumentIDs;
|
|
|
|
decls_block::TypeAliasTypeLayout::readRecord(
|
|
scratch, typealiasID, underlyingTypeID, substitutedTypeID,
|
|
parentTypeID, rawArgumentIDs);
|
|
|
|
TypeAliasDecl *alias = nullptr;
|
|
Type underlyingType;
|
|
if (MF.getContext().LangOpts.EnableDeserializationRecovery) {
|
|
auto underlyingTypeOrError = MF.getTypeChecked(underlyingTypeID);
|
|
if (!underlyingTypeOrError) {
|
|
// If we can't deserialize the underlying type, we can't be sure the
|
|
// actual typealias hasn't changed.
|
|
return underlyingTypeOrError.takeError();
|
|
}
|
|
|
|
underlyingType = underlyingTypeOrError.get();
|
|
|
|
if (auto aliasOrError = MF.getDeclChecked(typealiasID)) {
|
|
alias = dyn_cast<TypeAliasDecl>(aliasOrError.get());
|
|
} else {
|
|
// Pass through deserialization errors.
|
|
if (aliasOrError.errorIsA<FatalDeserializationError>())
|
|
return aliasOrError.takeError();
|
|
|
|
// We're going to recover by falling back to the underlying type, so
|
|
// just ignore the error.
|
|
MF.diagnoseAndConsumeError(aliasOrError.takeError());
|
|
}
|
|
|
|
if (!alias || !alias->getDeclaredInterfaceType()->isEqual(underlyingType)) {
|
|
// Fall back to the canonical type.
|
|
return underlyingType;
|
|
}
|
|
|
|
} else {
|
|
alias = dyn_cast<TypeAliasDecl>(MF.getDecl(typealiasID));
|
|
underlyingType = MF.getType(underlyingTypeID);
|
|
}
|
|
|
|
// Read the substituted type.
|
|
auto substitutedTypeOrError = MF.getTypeChecked(substitutedTypeID);
|
|
if (!substitutedTypeOrError)
|
|
return substitutedTypeOrError.takeError();
|
|
|
|
auto substitutedType = substitutedTypeOrError.get();
|
|
|
|
// Read generic arguments.
|
|
SmallVector<Type, 8> genericArgs;
|
|
for (TypeID ID : rawArgumentIDs) {
|
|
auto argTy = MF.getTypeChecked(ID);
|
|
if (!argTy)
|
|
return substitutedType;
|
|
|
|
genericArgs.push_back(argTy.get());
|
|
}
|
|
|
|
auto parentTypeOrError = MF.getTypeChecked(parentTypeID);
|
|
if (!parentTypeOrError)
|
|
return substitutedType;
|
|
|
|
// Look through compatibility aliases that are now unavailable.
|
|
if (alias && alias->isUnavailable() && alias->isCompatibilityAlias()) {
|
|
if (!alias->isGenericContext())
|
|
return alias->getUnderlyingType();
|
|
return substitutedType;
|
|
}
|
|
|
|
auto parentType = parentTypeOrError.get();
|
|
return TypeAliasType::get(alias, parentType, genericArgs, substitutedType);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(NOMINAL_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
DeclID declID;
|
|
TypeID parentID;
|
|
decls_block::NominalTypeLayout::readRecord(scratch, declID, parentID);
|
|
|
|
Expected<Type> parentTy = MF.getTypeChecked(parentID);
|
|
if (!parentTy)
|
|
return parentTy.takeError();
|
|
|
|
auto nominalOrError = MF.getDeclChecked(declID);
|
|
if (!nominalOrError)
|
|
return nominalOrError.takeError();
|
|
|
|
// Look through compatibility aliases.
|
|
if (auto *alias = dyn_cast<TypeAliasDecl>(nominalOrError.get())) {
|
|
// Reminder: TypeBase::getAs will look through sugar. But we don't want to
|
|
// do that here, so we do isa<> checks on the TypeBase itself instead of
|
|
// using the Type wrapper.
|
|
const TypeBase *underlyingTy = nullptr;
|
|
while (alias->isCompatibilityAlias()) {
|
|
underlyingTy = alias->getUnderlyingType().getPointer();
|
|
|
|
// If the underlying type is itself a typealias, it might be another
|
|
// compatibility alias, meaning we need to go around the loop again.
|
|
auto aliasTy = dyn_cast<TypeAliasType>(underlyingTy);
|
|
if (!aliasTy)
|
|
break;
|
|
alias = aliasTy->getDecl();
|
|
}
|
|
|
|
// We only want to use the type we found if it's a simple non-generic
|
|
// nominal type.
|
|
if (auto simpleNominalTy = dyn_cast_or_null<NominalType>(underlyingTy)) {
|
|
nominalOrError = simpleNominalTy->getDecl();
|
|
(void)!nominalOrError; // "Check" the llvm::Expected<> value.
|
|
}
|
|
}
|
|
|
|
auto nominal = dyn_cast<NominalTypeDecl>(nominalOrError.get());
|
|
if (!nominal) {
|
|
XRefTracePath tinyTrace{*nominalOrError.get()->getModuleContext()};
|
|
const DeclName fullName = cast<ValueDecl>(nominalOrError.get())->getName();
|
|
tinyTrace.addValue(fullName.getBaseIdentifier());
|
|
return llvm::make_error<XRefError>("declaration is not a nominal type",
|
|
tinyTrace, fullName);
|
|
}
|
|
return NominalType::get(nominal, parentTy.get(), MF.getContext());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(TUPLE_TYPE)(ModuleFile &MF,
|
|
SmallVectorImpl<uint64_t> &scratch,
|
|
StringRef blobData) {
|
|
// The tuple record itself is empty. Read all trailing elements.
|
|
SmallVector<TupleTypeElt, 8> elements;
|
|
while (true) {
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
break;
|
|
|
|
scratch.clear();
|
|
unsigned recordID = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != decls_block::TUPLE_TYPE_ELT)
|
|
break;
|
|
|
|
IdentifierID nameID;
|
|
TypeID typeID;
|
|
decls_block::TupleTypeEltLayout::readRecord(scratch, nameID, typeID);
|
|
|
|
auto elementTy = MF.getTypeChecked(typeID);
|
|
if (!elementTy)
|
|
return elementTy.takeError();
|
|
|
|
elements.emplace_back(elementTy.get(), MF.getIdentifier(nameID));
|
|
}
|
|
|
|
return TupleType::get(elements, MF.getContext());
|
|
}
|
|
|
|
Expected<Type>
|
|
detail::function_deserializer::deserialize(ModuleFile &MF,
|
|
SmallVectorImpl<uint64_t> &scratch,
|
|
StringRef blobData, bool isGeneric) {
|
|
TypeID resultID;
|
|
uint8_t rawRepresentation, rawDiffKind;
|
|
bool noescape = false, sendable, async, throws, hasSendingResult;
|
|
TypeID thrownErrorID;
|
|
GenericSignature genericSig;
|
|
TypeID clangTypeID;
|
|
TypeID rawIsolation;
|
|
|
|
if (!isGeneric) {
|
|
decls_block::FunctionTypeLayout::readRecord(
|
|
scratch, resultID, rawRepresentation, clangTypeID, noescape, sendable,
|
|
async, throws, thrownErrorID, rawDiffKind, rawIsolation,
|
|
hasSendingResult);
|
|
} else {
|
|
GenericSignatureID rawGenericSig;
|
|
decls_block::GenericFunctionTypeLayout::readRecord(
|
|
scratch, resultID, rawRepresentation, sendable, async, throws,
|
|
thrownErrorID, rawDiffKind, rawIsolation, hasSendingResult,
|
|
rawGenericSig);
|
|
genericSig = MF.getGenericSignature(rawGenericSig);
|
|
clangTypeID = 0;
|
|
}
|
|
|
|
auto representation = getActualFunctionTypeRepresentation(rawRepresentation);
|
|
if (!representation.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
Type thrownError;
|
|
if (thrownErrorID) {
|
|
auto thrownErrorTy = MF.getTypeChecked(thrownErrorID);
|
|
if (!thrownErrorTy)
|
|
return thrownErrorTy.takeError();
|
|
|
|
thrownError = thrownErrorTy.get();
|
|
}
|
|
|
|
auto diffKind = getActualDifferentiabilityKind(rawDiffKind);
|
|
if (!diffKind.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
const clang::Type *clangFunctionType = nullptr;
|
|
if (clangTypeID) {
|
|
auto loadedClangType = MF.getClangType(clangTypeID);
|
|
if (!loadedClangType)
|
|
return loadedClangType.takeError();
|
|
clangFunctionType = loadedClangType.get();
|
|
}
|
|
|
|
auto isolation = swift::FunctionTypeIsolation::forNonIsolated();
|
|
if (rawIsolation == unsigned(FunctionTypeIsolation::NonIsolated)) {
|
|
// do nothing
|
|
} else if (rawIsolation == unsigned(FunctionTypeIsolation::NonIsolatedNonsending)) {
|
|
isolation = swift::FunctionTypeIsolation::forNonIsolatedCaller();
|
|
} else if (rawIsolation == unsigned(FunctionTypeIsolation::Parameter)) {
|
|
isolation = swift::FunctionTypeIsolation::forParameter();
|
|
} else if (rawIsolation == unsigned(FunctionTypeIsolation::Erased)) {
|
|
isolation = swift::FunctionTypeIsolation::forErased();
|
|
} else {
|
|
TypeID globalActorTypeID =
|
|
rawIsolation - unsigned(FunctionTypeIsolation::GlobalActorOffset);
|
|
|
|
auto globalActorTy = MF.getTypeChecked(globalActorTypeID);
|
|
if (!globalActorTy)
|
|
return globalActorTy.takeError();
|
|
isolation = swift::FunctionTypeIsolation::forGlobalActor(globalActorTy.get());
|
|
}
|
|
|
|
auto info = FunctionType::ExtInfoBuilder(
|
|
*representation, noescape, throws, thrownError, *diffKind,
|
|
clangFunctionType, isolation,
|
|
/*LifetimeDependenceInfo */ {}, hasSendingResult)
|
|
.withSendable(sendable)
|
|
.withAsync(async)
|
|
.build();
|
|
|
|
auto resultTy = MF.getTypeChecked(resultID);
|
|
if (!resultTy)
|
|
return resultTy.takeError();
|
|
|
|
SmallVector<AnyFunctionType::Param, 8> params;
|
|
while (true) {
|
|
BCOffsetRAII restoreOffset(MF.DeclTypeCursor);
|
|
llvm::BitstreamEntry entry =
|
|
MF.fatalIfUnexpected(MF.DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
break;
|
|
|
|
scratch.clear();
|
|
unsigned recordID = MF.fatalIfUnexpected(
|
|
MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != decls_block::FUNCTION_PARAM)
|
|
break;
|
|
|
|
restoreOffset.reset();
|
|
|
|
IdentifierID labelID;
|
|
IdentifierID internalLabelID;
|
|
TypeID typeID;
|
|
bool isVariadic, isAutoClosure, isNonEphemeral, isIsolated,
|
|
isCompileTimeLiteral, isConstValue;
|
|
bool isNoDerivative, isSending, isAddressable;
|
|
unsigned rawOwnership;
|
|
decls_block::FunctionParamLayout::readRecord(
|
|
scratch, labelID, internalLabelID, typeID, isVariadic, isAutoClosure,
|
|
isNonEphemeral, rawOwnership, isIsolated, isNoDerivative,
|
|
isCompileTimeLiteral, isConstValue, isSending, isAddressable);
|
|
|
|
auto ownership = getActualParamDeclSpecifier(
|
|
(serialization::ParamDeclSpecifier)rawOwnership);
|
|
if (!ownership)
|
|
return MF.diagnoseFatal();
|
|
|
|
auto paramTy = MF.getTypeChecked(typeID);
|
|
if (!paramTy)
|
|
return paramTy.takeError();
|
|
|
|
params.emplace_back(paramTy.get(), MF.getIdentifier(labelID),
|
|
ParameterTypeFlags(isVariadic, isAutoClosure,
|
|
isNonEphemeral, *ownership,
|
|
isIsolated, isNoDerivative,
|
|
isCompileTimeLiteral, isSending,
|
|
isAddressable, isConstValue),
|
|
MF.getIdentifier(internalLabelID));
|
|
}
|
|
|
|
SmallVector<LifetimeDependenceInfo, 1> lifetimeDependencies;
|
|
|
|
while (auto lifetimeDependence = MF.maybeReadLifetimeDependence()) {
|
|
lifetimeDependencies.push_back(*lifetimeDependence);
|
|
}
|
|
if (!lifetimeDependencies.empty()) {
|
|
info = info.withLifetimeDependencies(
|
|
MF.getContext().AllocateCopy(lifetimeDependencies));
|
|
}
|
|
|
|
if (!isGeneric) {
|
|
assert(genericSig.isNull());
|
|
return FunctionType::get(params, resultTy.get(), info);
|
|
}
|
|
|
|
assert(!genericSig.isNull());
|
|
return GenericFunctionType::get(genericSig, params, resultTy.get(), info);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(FUNCTION_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
return detail::function_deserializer::deserialize(MF, scratch, blobData, /*isGeneric*/ false);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(GENERIC_FUNCTION_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
return detail::function_deserializer::deserialize(MF, scratch, blobData, /*isGeneric*/ true);
|
|
}
|
|
|
|
template <typename Layout, typename ASTType, bool CanBeThin>
|
|
Expected<Type> deserializeAnyMetatypeType(ModuleFile &MF,
|
|
ArrayRef<uint64_t> scratch,
|
|
StringRef blobData) {
|
|
TypeID instanceID;
|
|
uint8_t repr;
|
|
Layout::readRecord(scratch, instanceID, repr);
|
|
|
|
auto instanceType = MF.getTypeChecked(instanceID);
|
|
if (!instanceType)
|
|
return instanceType.takeError();
|
|
|
|
switch (repr) {
|
|
case serialization::MetatypeRepresentation::MR_None:
|
|
return ASTType::get(instanceType.get());
|
|
|
|
case serialization::MetatypeRepresentation::MR_Thin:
|
|
if (!CanBeThin)
|
|
return MF.diagnoseFatal();
|
|
return ASTType::get(instanceType.get(),
|
|
swift::MetatypeRepresentation::Thin);
|
|
|
|
case serialization::MetatypeRepresentation::MR_Thick:
|
|
return ASTType::get(instanceType.get(),
|
|
swift::MetatypeRepresentation::Thick);
|
|
|
|
case serialization::MetatypeRepresentation::MR_ObjC:
|
|
return ASTType::get(instanceType.get(),
|
|
swift::MetatypeRepresentation::ObjC);
|
|
|
|
default:
|
|
return MF.diagnoseFatal();
|
|
}
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(EXISTENTIAL_METATYPE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
return deserializeAnyMetatypeType<decls_block::ExistentialMetatypeTypeLayout,
|
|
ExistentialMetatypeType,
|
|
/*CanBeThin*/ false>(MF, scratch, blobData);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(METATYPE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
return deserializeAnyMetatypeType<decls_block::MetatypeTypeLayout,
|
|
MetatypeType, /*CanBeThin*/ true>(
|
|
MF, scratch, blobData);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(DYNAMIC_SELF_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID selfID;
|
|
decls_block::DynamicSelfTypeLayout::readRecord(scratch, selfID);
|
|
return DynamicSelfType::get(MF.getType(selfID), MF.getContext());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(REFERENCE_STORAGE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
uint8_t rawOwnership;
|
|
TypeID objectTypeID;
|
|
decls_block::ReferenceStorageTypeLayout::readRecord(scratch, rawOwnership,
|
|
objectTypeID);
|
|
|
|
auto ownership = getActualReferenceOwnership(
|
|
(serialization::ReferenceOwnership)rawOwnership);
|
|
if (!ownership.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
auto objectTy = MF.getTypeChecked(objectTypeID);
|
|
if (!objectTy)
|
|
return objectTy.takeError();
|
|
|
|
return ReferenceStorageType::get(objectTy.get(), ownership.value(),
|
|
MF.getContext());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(PRIMARY_ARCHETYPE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
GenericSignatureID sigID;
|
|
TypeID interfaceTypeID;
|
|
|
|
decls_block::PrimaryArchetypeTypeLayout::readRecord(scratch, sigID,
|
|
interfaceTypeID);
|
|
|
|
auto sigOrError = MF.getGenericSignatureChecked(sigID);
|
|
if (!sigOrError)
|
|
return sigOrError.takeError();
|
|
|
|
auto interfaceTypeOrError = MF.getTypeChecked(interfaceTypeID);
|
|
if (!interfaceTypeOrError)
|
|
return interfaceTypeOrError.takeError();
|
|
|
|
Type contextType =
|
|
sigOrError.get().getGenericEnvironment()->mapTypeIntoEnvironment(
|
|
interfaceTypeOrError.get());
|
|
|
|
if (contextType->hasError())
|
|
return MF.diagnoseFatal();
|
|
|
|
return contextType;
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(EXISTENTIAL_ARCHETYPE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID interfaceID;
|
|
GenericEnvironmentID genericEnvID;
|
|
|
|
decls_block::ExistentialArchetypeTypeLayout::readRecord(scratch,
|
|
interfaceID,
|
|
genericEnvID);
|
|
|
|
auto interfaceTypeOrError = MF.getTypeChecked(interfaceID);
|
|
if (!interfaceTypeOrError)
|
|
return interfaceTypeOrError.takeError();
|
|
|
|
auto envOrError = MF.getGenericEnvironmentChecked(genericEnvID);
|
|
if (!envOrError)
|
|
return envOrError.takeError();
|
|
|
|
return envOrError.get()->mapTypeIntoEnvironment(interfaceTypeOrError.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(OPAQUE_ARCHETYPE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
DeclID opaqueDeclID;
|
|
TypeID interfaceTypeID;
|
|
SubstitutionMapID subsID;
|
|
decls_block::OpaqueArchetypeTypeLayout::readRecord(scratch, opaqueDeclID,
|
|
interfaceTypeID, subsID);
|
|
|
|
auto opaqueTypeOrError = MF.getDeclChecked(opaqueDeclID);
|
|
if (!opaqueTypeOrError)
|
|
return opaqueTypeOrError.takeError();
|
|
|
|
auto interfaceTypeOrError = MF.getTypeChecked(interfaceTypeID);
|
|
if (!interfaceTypeOrError)
|
|
return interfaceTypeOrError.takeError();
|
|
|
|
auto opaqueDecl = cast<OpaqueTypeDecl>(opaqueTypeOrError.get());
|
|
auto subsOrError = MF.getSubstitutionMapChecked(subsID);
|
|
if (!subsOrError)
|
|
return subsOrError.takeError();
|
|
|
|
return OpaqueTypeArchetypeType::get(opaqueDecl, interfaceTypeOrError.get(),
|
|
subsOrError.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(PACK_ARCHETYPE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
GenericSignatureID sigID;
|
|
TypeID interfaceTypeID;
|
|
|
|
decls_block::PackArchetypeTypeLayout::readRecord(scratch, sigID,
|
|
interfaceTypeID);
|
|
|
|
auto sig = MF.getGenericSignature(sigID);
|
|
if (!sig)
|
|
return MF.diagnoseFatal();
|
|
|
|
Type interfaceType = MF.getType(interfaceTypeID);
|
|
Type contextType =
|
|
sig.getGenericEnvironment()->mapTypeIntoEnvironment(interfaceType);
|
|
|
|
if (contextType->hasError())
|
|
return MF.diagnoseFatal();
|
|
|
|
return contextType;
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(ELEMENT_ARCHETYPE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID interfaceID;
|
|
GenericEnvironmentID genericEnvID;
|
|
|
|
decls_block::ElementArchetypeTypeLayout::readRecord(scratch,
|
|
interfaceID,
|
|
genericEnvID);
|
|
|
|
auto interfaceTypeOrError = MF.getTypeChecked(interfaceID);
|
|
if (!interfaceTypeOrError)
|
|
return interfaceTypeOrError.takeError();
|
|
|
|
auto envOrError = MF.getGenericEnvironmentChecked(genericEnvID);
|
|
if (!envOrError)
|
|
return envOrError.takeError();
|
|
|
|
return envOrError.get()->mapTypeIntoEnvironment(interfaceTypeOrError.get());
|
|
}
|
|
|
|
Expected<Type>
|
|
DESERIALIZE_TYPE(GENERIC_TYPE_PARAM_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
unsigned rawParamKind;
|
|
bool hasDecl;
|
|
unsigned depth;
|
|
unsigned weight;
|
|
unsigned index;
|
|
DeclID declOrIdentifier;
|
|
TypeID valueTypeID;
|
|
|
|
decls_block::GenericTypeParamTypeLayout::readRecord(
|
|
scratch, rawParamKind, hasDecl, depth, weight, index, declOrIdentifier,
|
|
valueTypeID);
|
|
|
|
auto paramKind = getActualParamKind(rawParamKind);
|
|
if (!paramKind)
|
|
return MF.diagnoseFatal();
|
|
|
|
if (hasDecl) {
|
|
auto genericParamOrError = MF.getDeclChecked(declOrIdentifier);
|
|
if (!genericParamOrError)
|
|
return genericParamOrError.takeError();
|
|
|
|
auto genericParam =
|
|
dyn_cast_or_null<GenericTypeParamDecl>(genericParamOrError.get());
|
|
if (!genericParam)
|
|
return MF.diagnoseFatal();
|
|
|
|
ASSERT(*paramKind == genericParam->getParamKind());
|
|
ASSERT(depth == genericParam->getDepth());
|
|
ASSERT(index == genericParam->getIndex());
|
|
|
|
return genericParam->getDeclaredInterfaceType();
|
|
}
|
|
|
|
auto valueType = MF.getTypeChecked(valueTypeID);
|
|
if (!valueType)
|
|
return valueType.takeError();
|
|
|
|
if (declOrIdentifier == 0) {
|
|
return GenericTypeParamType::get(*paramKind, depth, index, weight, *valueType,
|
|
MF.getContext());
|
|
}
|
|
|
|
ASSERT(weight == 0);
|
|
auto name = MF.getDeclBaseName(declOrIdentifier).getIdentifier();
|
|
return GenericTypeParamType::get(name, *paramKind, depth, index, *valueType,
|
|
MF.getContext());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(PROTOCOL_COMPOSITION_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
bool hasExplicitAnyObject, hasInverseCopyable, hasInverseEscapable;
|
|
ArrayRef<uint64_t> rawProtocolIDs;
|
|
|
|
decls_block::ProtocolCompositionTypeLayout::readRecord(
|
|
scratch,
|
|
hasExplicitAnyObject,
|
|
hasInverseCopyable,
|
|
hasInverseEscapable,
|
|
rawProtocolIDs);
|
|
|
|
SmallVector<Type, 4> protocols;
|
|
for (TypeID protoID : rawProtocolIDs) {
|
|
auto protoTy = MF.getTypeChecked(protoID);
|
|
if (!protoTy)
|
|
return protoTy.takeError();
|
|
protocols.push_back(protoTy.get());
|
|
}
|
|
|
|
InvertibleProtocolSet inverses;
|
|
if (hasInverseCopyable)
|
|
inverses.insert(InvertibleProtocolKind::Copyable);
|
|
if (hasInverseEscapable)
|
|
inverses.insert(InvertibleProtocolKind::Escapable);
|
|
|
|
return ProtocolCompositionType::get(MF.getContext(), protocols, inverses,
|
|
hasExplicitAnyObject);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(PARAMETERIZED_PROTOCOL_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
|
|
uint64_t baseTyID;
|
|
ArrayRef<uint64_t> rawArgIDs;
|
|
|
|
decls_block::ParameterizedProtocolTypeLayout::readRecord(scratch, baseTyID,
|
|
rawArgIDs);
|
|
|
|
auto baseTy = MF.getTypeChecked(baseTyID);
|
|
if (!baseTy)
|
|
return baseTy.takeError();
|
|
|
|
SmallVector<Type, 4> args;
|
|
for (TypeID argID : rawArgIDs) {
|
|
auto argTy = MF.getTypeChecked(argID);
|
|
if (!argTy)
|
|
return argTy.takeError();
|
|
args.push_back(argTy.get());
|
|
}
|
|
|
|
return ParameterizedProtocolType::get(
|
|
MF.getContext(), (*baseTy)->castTo<ProtocolType>(), args);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(EXISTENTIAL_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID constraintID;
|
|
decls_block::ExistentialTypeLayout::readRecord(scratch, constraintID);
|
|
|
|
auto constraintType = MF.getTypeChecked(constraintID);
|
|
if (!constraintType)
|
|
return constraintType.takeError();
|
|
|
|
return ExistentialType::get(constraintType.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(DEPENDENT_MEMBER_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID baseID;
|
|
DeclID assocTypeID;
|
|
|
|
decls_block::DependentMemberTypeLayout::readRecord(scratch, baseID,
|
|
assocTypeID);
|
|
auto assocType = MF.getDeclChecked(assocTypeID);
|
|
if (!assocType)
|
|
return assocType.takeError();
|
|
|
|
return DependentMemberType::get(MF.getType(baseID),
|
|
cast<AssociatedTypeDecl>(assocType.get()));
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(BOUND_GENERIC_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
DeclID declID;
|
|
TypeID parentID;
|
|
ArrayRef<uint64_t> rawArgumentIDs;
|
|
|
|
decls_block::BoundGenericTypeLayout::readRecord(scratch, declID, parentID,
|
|
rawArgumentIDs);
|
|
|
|
auto nominalOrError = MF.getDeclChecked(declID);
|
|
if (!nominalOrError)
|
|
return nominalOrError.takeError();
|
|
auto nominal = cast<NominalTypeDecl>(nominalOrError.get());
|
|
|
|
// FIXME: Check this?
|
|
auto parentTy = MF.getType(parentID);
|
|
|
|
SmallVector<Type, 8> genericArgs;
|
|
for (TypeID ID : rawArgumentIDs) {
|
|
auto argTy = MF.getTypeChecked(ID);
|
|
if (!argTy)
|
|
return argTy.takeError();
|
|
|
|
genericArgs.push_back(argTy.get());
|
|
}
|
|
|
|
if (auto clangDecl = nominal->getClangDecl()) {
|
|
if (auto ctd = dyn_cast<clang::ClassTemplateDecl>(clangDecl)) {
|
|
auto clangImporter = static_cast<ClangImporter *>(
|
|
nominal->getASTContext().getClangModuleLoader());
|
|
|
|
SmallVector<Type, 2> typesOfGenericArgs;
|
|
for (auto arg : genericArgs) {
|
|
typesOfGenericArgs.push_back(arg);
|
|
}
|
|
|
|
SmallVector<clang::TemplateArgument, 2> templateArguments;
|
|
std::unique_ptr<TemplateInstantiationError> error =
|
|
MF.getContext().getClangTemplateArguments(
|
|
ctd->getTemplateParameters(), typesOfGenericArgs,
|
|
templateArguments);
|
|
|
|
auto instantiation = clangImporter->instantiateCXXClassTemplate(
|
|
const_cast<clang::ClassTemplateDecl *>(ctd), templateArguments);
|
|
|
|
instantiation->setTemplateInstantiationType(
|
|
BoundGenericType::get(nominal, parentTy, genericArgs));
|
|
return instantiation->getDeclaredInterfaceType();
|
|
}
|
|
}
|
|
|
|
return BoundGenericType::get(nominal, parentTy, genericArgs);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(SIL_BLOCK_STORAGE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID captureID;
|
|
decls_block::SILBlockStorageTypeLayout::readRecord(scratch, captureID);
|
|
return SILBlockStorageType::get(MF.getType(captureID)->getCanonicalType());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(SIL_MOVE_ONLY_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID innerType;
|
|
decls_block::SILMoveOnlyWrappedTypeLayout::readRecord(scratch, innerType);
|
|
return SILMoveOnlyWrappedType::get(MF.getType(innerType)->getCanonicalType());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(SIL_BOX_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
SILLayoutID layoutID;
|
|
SubstitutionMapID subMapID;
|
|
decls_block::SILBoxTypeLayout::readRecord(scratch, layoutID, subMapID);
|
|
|
|
// Get the layout.
|
|
auto getLayout = [&MF](SILLayoutID layoutID) -> Expected<SILLayout *> {
|
|
assert(layoutID > 0 && layoutID <= MF.SILLayouts.size() &&
|
|
"invalid layout ID");
|
|
|
|
auto &layoutOrOffset = MF.SILLayouts[layoutID - 1];
|
|
if (layoutOrOffset.isComplete()) {
|
|
return layoutOrOffset;
|
|
}
|
|
|
|
BCOffsetRAII saveOffset(MF.DeclTypeCursor);
|
|
if (auto error = MF.diagnoseFatalIfNotSuccess(
|
|
MF.DeclTypeCursor.JumpToBit(layoutOrOffset)))
|
|
return std::move(error);
|
|
auto layout = MF.readSILLayout(MF.DeclTypeCursor);
|
|
if (!layout)
|
|
return MF.diagnoseFatal();
|
|
layoutOrOffset = layout;
|
|
return layout;
|
|
};
|
|
|
|
auto layout = getLayout(layoutID);
|
|
if (!layout)
|
|
return layout.takeError();
|
|
if (!*layout)
|
|
return nullptr;
|
|
|
|
auto subMapOrError = MF.getSubstitutionMapChecked(subMapID);
|
|
if (!subMapOrError)
|
|
return subMapOrError.takeError();
|
|
|
|
return SILBoxType::get(MF.getContext(), *layout, subMapOrError.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(SIL_FUNCTION_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
bool async;
|
|
uint8_t rawCoroutineKind;
|
|
uint8_t rawCalleeConvention;
|
|
uint8_t rawRepresentation;
|
|
uint8_t rawDiffKind;
|
|
bool pseudogeneric = false;
|
|
bool unimplementable;
|
|
bool sendable;
|
|
bool noescape;
|
|
bool erasedIsolation;
|
|
bool hasErrorResult;
|
|
unsigned numParams;
|
|
unsigned numYields;
|
|
unsigned numResults;
|
|
GenericSignatureID rawInvocationGenericSig;
|
|
SubstitutionMapID rawInvocationSubs;
|
|
SubstitutionMapID rawPatternSubs;
|
|
ArrayRef<uint64_t> variableData;
|
|
ClangTypeID clangFunctionTypeID;
|
|
|
|
decls_block::SILFunctionTypeLayout::readRecord(
|
|
scratch, sendable, async, rawCoroutineKind, rawCalleeConvention,
|
|
rawRepresentation, pseudogeneric, noescape, unimplementable,
|
|
erasedIsolation, rawDiffKind, hasErrorResult,
|
|
numParams, numYields, numResults, rawInvocationGenericSig,
|
|
rawInvocationSubs, rawPatternSubs, clangFunctionTypeID, variableData);
|
|
|
|
// Process the ExtInfo.
|
|
auto representation =
|
|
getActualSILFunctionTypeRepresentation(rawRepresentation);
|
|
if (!representation.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
auto diffKind = getActualDifferentiabilityKind(rawDiffKind);
|
|
if (!diffKind.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
const clang::Type *clangFunctionType = nullptr;
|
|
if (clangFunctionTypeID) {
|
|
auto clangType = MF.getClangType(clangFunctionTypeID);
|
|
if (!clangType)
|
|
return clangType.takeError();
|
|
clangFunctionType = clangType.get();
|
|
}
|
|
|
|
auto isolation = SILFunctionTypeIsolation::forUnknown();
|
|
if (erasedIsolation)
|
|
isolation = SILFunctionTypeIsolation::forErased();
|
|
|
|
auto extInfo = SILFunctionType::ExtInfoBuilder(
|
|
*representation, pseudogeneric, noescape, sendable, async,
|
|
unimplementable, isolation, *diffKind, clangFunctionType,
|
|
/*LifetimeDependenceInfo*/ {})
|
|
.build();
|
|
|
|
// Process the coroutine kind.
|
|
auto coroutineKind = getActualSILCoroutineKind(rawCoroutineKind);
|
|
if (!coroutineKind.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
// Process the callee convention.
|
|
auto calleeConvention = getActualParameterConvention(rawCalleeConvention);
|
|
if (!calleeConvention.has_value())
|
|
return MF.diagnoseFatal();
|
|
|
|
auto processParameter =
|
|
[&](TypeID typeID, uint64_t rawConvention,
|
|
uint64_t rawOptions) -> llvm::Expected<SILParameterInfo> {
|
|
auto convention = getActualParameterConvention(rawConvention);
|
|
if (!convention)
|
|
return MF.diagnoseFatal();
|
|
auto type = MF.getTypeChecked(typeID);
|
|
if (!type)
|
|
return type.takeError();
|
|
// If paramOptions is none, then we found an option that we did not know how
|
|
// to deserialize meaning something is out of sync... signal an error!
|
|
auto paramOptions = getActualSILParameterOptions(rawOptions);
|
|
if (!paramOptions)
|
|
return MF.diagnoseFatal();
|
|
return SILParameterInfo(type.get()->getCanonicalType(), *convention,
|
|
*paramOptions);
|
|
};
|
|
|
|
auto processYield =
|
|
[&](TypeID typeID,
|
|
uint64_t rawConvention) -> llvm::Expected<SILYieldInfo> {
|
|
auto convention = getActualParameterConvention(rawConvention);
|
|
if (!convention)
|
|
return MF.diagnoseFatal();
|
|
auto type = MF.getTypeChecked(typeID);
|
|
if (!type)
|
|
return type.takeError();
|
|
return SILYieldInfo(type.get()->getCanonicalType(), *convention);
|
|
};
|
|
|
|
auto processResult =
|
|
[&](TypeID typeID, uint64_t rawConvention,
|
|
uint64_t rawOptions) -> llvm::Expected<SILResultInfo> {
|
|
auto convention = getActualResultConvention(rawConvention);
|
|
if (!convention)
|
|
return MF.diagnoseFatal();
|
|
auto type = MF.getTypeChecked(typeID);
|
|
if (!type)
|
|
return type.takeError();
|
|
|
|
// If resultOptions is none, then we found an option that we did not know
|
|
// how to deserialize meaning something is out of sync... signal an error!
|
|
auto resultOptions = getActualSILResultOptions(rawOptions);
|
|
if (!resultOptions)
|
|
return MF.diagnoseFatal();
|
|
return SILResultInfo(type.get()->getCanonicalType(), *convention,
|
|
*resultOptions);
|
|
};
|
|
|
|
// Bounds check. FIXME: overflow
|
|
unsigned entriesPerParam =
|
|
diffKind != swift::DifferentiabilityKind::NonDifferentiable ? 3 : 2;
|
|
if (entriesPerParam * numParams + 2 * numResults +
|
|
2 * unsigned(hasErrorResult) >
|
|
variableData.size()) {
|
|
return MF.diagnoseFatal();
|
|
}
|
|
|
|
unsigned nextVariableDataIndex = 0;
|
|
|
|
// Process the parameters.
|
|
SmallVector<SILParameterInfo, 8> allParams;
|
|
allParams.reserve(numParams);
|
|
for (unsigned i = 0; i != numParams; ++i) {
|
|
auto typeID = variableData[nextVariableDataIndex++];
|
|
auto rawConvention = variableData[nextVariableDataIndex++];
|
|
uint64_t rawOptions = variableData[nextVariableDataIndex++];
|
|
auto param = processParameter(typeID, rawConvention, rawOptions);
|
|
if (!param)
|
|
return param.takeError();
|
|
allParams.push_back(param.get());
|
|
}
|
|
|
|
// Process the yields.
|
|
SmallVector<SILYieldInfo, 8> allYields;
|
|
allYields.reserve(numYields);
|
|
for (unsigned i = 0; i != numYields; ++i) {
|
|
auto typeID = variableData[nextVariableDataIndex++];
|
|
auto rawConvention = variableData[nextVariableDataIndex++];
|
|
auto yield = processYield(typeID, rawConvention);
|
|
if (!yield)
|
|
return yield.takeError();
|
|
allYields.push_back(yield.get());
|
|
}
|
|
|
|
// Process the results.
|
|
SmallVector<SILResultInfo, 8> allResults;
|
|
allParams.reserve(numResults);
|
|
for (unsigned i = 0; i != numResults; ++i) {
|
|
auto typeID = variableData[nextVariableDataIndex++];
|
|
auto rawConvention = variableData[nextVariableDataIndex++];
|
|
uint64_t rawOptions = variableData[nextVariableDataIndex++];
|
|
auto result = processResult(typeID, rawConvention, rawOptions);
|
|
if (!result)
|
|
return result.takeError();
|
|
allResults.push_back(result.get());
|
|
}
|
|
|
|
// Process the error result.
|
|
std::optional<SILResultInfo> errorResult;
|
|
if (hasErrorResult) {
|
|
auto typeID = variableData[nextVariableDataIndex++];
|
|
auto rawConvention = variableData[nextVariableDataIndex++];
|
|
uint64_t rawOptions = 0;
|
|
auto maybeErrorResult = processResult(typeID, rawConvention, rawOptions);
|
|
if (!maybeErrorResult)
|
|
return maybeErrorResult.takeError();
|
|
errorResult = maybeErrorResult.get();
|
|
}
|
|
|
|
ProtocolConformanceRef witnessMethodConformance;
|
|
if (*representation == swift::SILFunctionTypeRepresentation::WitnessMethod) {
|
|
auto conformanceID = variableData[nextVariableDataIndex++];
|
|
SET_OR_RETURN_ERROR(witnessMethodConformance,
|
|
MF.getConformanceChecked(conformanceID));
|
|
}
|
|
|
|
GenericSignature invocationSig =
|
|
MF.getGenericSignature(rawInvocationGenericSig);
|
|
auto invocationSubsOrErr = MF.getSubstitutionMapChecked(rawInvocationSubs);
|
|
if (!invocationSubsOrErr)
|
|
return invocationSubsOrErr.takeError();
|
|
auto patternSubsOrErr = MF.getSubstitutionMapChecked(rawPatternSubs);
|
|
if (!patternSubsOrErr)
|
|
return patternSubsOrErr.takeError();
|
|
|
|
SmallVector<LifetimeDependenceInfo, 1> lifetimeDependencies;
|
|
|
|
while (auto lifetimeDependence = MF.maybeReadLifetimeDependence()) {
|
|
lifetimeDependencies.push_back(*lifetimeDependence);
|
|
}
|
|
|
|
if (!lifetimeDependencies.empty()) {
|
|
extInfo = extInfo.withLifetimeDependencies(
|
|
MF.getContext().AllocateCopy(lifetimeDependencies));
|
|
}
|
|
|
|
return SILFunctionType::get(invocationSig, extInfo, coroutineKind.value(),
|
|
calleeConvention.value(), allParams, allYields,
|
|
allResults, errorResult,
|
|
patternSubsOrErr.get().getCanonical(),
|
|
invocationSubsOrErr.get().getCanonical(),
|
|
MF.getContext(), witnessMethodConformance);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(ARRAY_SLICE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID baseID;
|
|
decls_block::ArraySliceTypeLayout::readRecord(scratch, baseID);
|
|
|
|
auto baseTy = MF.getTypeChecked(baseID);
|
|
if (!baseTy)
|
|
return baseTy.takeError();
|
|
|
|
return ArraySliceType::get(baseTy.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(INLINE_ARRAY_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID countID, elementID;
|
|
decls_block::InlineArrayTypeLayout::readRecord(scratch, countID, elementID);
|
|
|
|
auto countTy = MF.getTypeChecked(countID);
|
|
if (!countTy)
|
|
return countTy.takeError();
|
|
|
|
auto elementTy = MF.getTypeChecked(elementID);
|
|
if (!elementTy)
|
|
return elementTy.takeError();
|
|
|
|
return InlineArrayType::get(countTy.get(), elementTy.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(DICTIONARY_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID keyID, valueID;
|
|
decls_block::DictionaryTypeLayout::readRecord(scratch, keyID, valueID);
|
|
|
|
auto keyTy = MF.getTypeChecked(keyID);
|
|
if (!keyTy)
|
|
return keyTy.takeError();
|
|
|
|
auto valueTy = MF.getTypeChecked(valueID);
|
|
if (!valueTy)
|
|
return valueTy.takeError();
|
|
|
|
return DictionaryType::get(keyTy.get(), valueTy.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(OPTIONAL_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID baseID;
|
|
decls_block::OptionalTypeLayout::readRecord(scratch, baseID);
|
|
|
|
auto baseTy = MF.getTypeChecked(baseID);
|
|
if (!baseTy)
|
|
return baseTy.takeError();
|
|
|
|
return OptionalType::get(baseTy.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(VARIADIC_SEQUENCE_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID baseID;
|
|
decls_block::VariadicSequenceTypeLayout::readRecord(scratch, baseID);
|
|
|
|
auto baseTy = MF.getTypeChecked(baseID);
|
|
if (!baseTy)
|
|
return baseTy.takeError();
|
|
|
|
return VariadicSequenceType::get(baseTy.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(UNBOUND_GENERIC_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
DeclID genericID;
|
|
TypeID parentID;
|
|
decls_block::UnboundGenericTypeLayout::readRecord(scratch, genericID,
|
|
parentID);
|
|
|
|
auto nominalOrError = MF.getDeclChecked(genericID);
|
|
if (!nominalOrError)
|
|
return nominalOrError.takeError();
|
|
auto genericDecl = cast<GenericTypeDecl>(nominalOrError.get());
|
|
|
|
// FIXME: Check this?
|
|
auto parentTy = MF.getType(parentID);
|
|
|
|
return UnboundGenericType::get(genericDecl, parentTy, MF.getContext());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(PACK_EXPANSION_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID patternID;
|
|
TypeID countID;
|
|
decls_block::PackExpansionTypeLayout::readRecord(scratch, patternID, countID);
|
|
|
|
auto patternTy = MF.getTypeChecked(patternID);
|
|
if (!patternTy)
|
|
return patternTy.takeError();
|
|
auto countTy = MF.getTypeChecked(countID);
|
|
if (!countTy)
|
|
return countTy.takeError();
|
|
|
|
return PackExpansionType::get(patternTy.get(), countTy.get());
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(PACK_ELEMENT_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
TypeID packID;
|
|
unsigned level;
|
|
decls_block::PackElementTypeLayout::readRecord(scratch, packID, level);
|
|
|
|
auto packType = MF.getTypeChecked(packID);
|
|
if (!packType)
|
|
return packType.takeError();
|
|
|
|
return PackElementType::get(packType.get(), level);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(PACK_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
ArrayRef<uint64_t> elementTypeIDs;
|
|
decls_block::PackTypeLayout::readRecord(scratch, elementTypeIDs);
|
|
|
|
SmallVector<Type, 8> elementTypes;
|
|
for (auto elementTypeID : elementTypeIDs) {
|
|
auto elementType = MF.getTypeChecked(elementTypeID);
|
|
if (!elementType)
|
|
return elementType.takeError();
|
|
elementTypes.push_back(elementType.get());
|
|
}
|
|
|
|
return PackType::get(MF.getContext(), elementTypes);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(SIL_PACK_TYPE)(
|
|
ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
|
|
unsigned elementIsAddress;
|
|
ArrayRef<uint64_t> elementTypeIDs;
|
|
decls_block::SILPackTypeLayout::readRecord(scratch, elementIsAddress,
|
|
elementTypeIDs);
|
|
|
|
SmallVector<CanType, 8> elementTypes;
|
|
for (auto elementTypeID : elementTypeIDs) {
|
|
auto elementType = MF.getTypeChecked(elementTypeID);
|
|
if (!elementType)
|
|
return elementType.takeError();
|
|
elementTypes.push_back(elementType.get()->getCanonicalType());
|
|
}
|
|
|
|
return SILPackType::get(MF.getContext(),
|
|
SILPackType::ExtInfo{bool(elementIsAddress)},
|
|
elementTypes);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(ERROR_TYPE)(ModuleFile &MF,
|
|
SmallVectorImpl<uint64_t> &scratch,
|
|
StringRef blobData) {
|
|
auto &ctx = MF.getContext();
|
|
TypeID origID;
|
|
decls_block::ErrorTypeLayout::readRecord(scratch, origID);
|
|
|
|
auto origTyOrError = MF.getTypeChecked(origID);
|
|
if (!origTyOrError)
|
|
return origTyOrError.takeError();
|
|
|
|
auto origTy = *origTyOrError;
|
|
auto diagId = MF.allowCompilerErrors()
|
|
? diag::serialization_allowing_error_type
|
|
: diag::serialization_error_type;
|
|
// Generally not a super useful diagnostic, so only output once if there
|
|
// hasn't been any other diagnostic yet to ensure nothing slips by and
|
|
// causes SILGen to crash.
|
|
if (!ctx.hadError()) {
|
|
ctx.Diags.diagnose(SourceLoc(), diagId, StringRef(origTy.getString()),
|
|
MF.getAssociatedModule()->getNameStr());
|
|
}
|
|
|
|
if (!origTy)
|
|
return ErrorType::get(ctx);
|
|
return ErrorType::get(origTy);
|
|
}
|
|
|
|
Expected<Type> DESERIALIZE_TYPE(INTEGER_TYPE)(ModuleFile &MF,
|
|
SmallVectorImpl<uint64_t> &scratch,
|
|
StringRef blobData) {
|
|
auto &ctx = MF.getContext();
|
|
bool isNegative;
|
|
|
|
decls_block::IntegerTypeLayout::readRecord(scratch, isNegative);
|
|
|
|
return IntegerType::get(blobData, isNegative, ctx);
|
|
}
|
|
} // namespace decls_block
|
|
} // namespace serialization
|
|
}
|
|
|
|
Expected<Type> ModuleFile::getTypeChecked(TypeID TID) {
|
|
if (TID == 0)
|
|
return Type();
|
|
|
|
assert(TID <= Types.size() && "invalid type ID");
|
|
auto &typeOrOffset = Types[TID-1];
|
|
|
|
if (typeOrOffset.isComplete())
|
|
return typeOrOffset;
|
|
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error =
|
|
diagnoseFatalIfNotSuccess(DeclTypeCursor.JumpToBit(typeOrOffset)))
|
|
return std::move(error);
|
|
|
|
{
|
|
if (auto s = getContext().Stats)
|
|
++s->getFrontendCounters().NumTypesDeserialized;
|
|
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance());
|
|
|
|
if (entry.Kind != llvm::BitstreamEntry::Record) {
|
|
// We don't know how to serialize types represented by sub-blocks.
|
|
return diagnoseFatal();
|
|
}
|
|
|
|
SmallVector<uint64_t, 64> scratch;
|
|
StringRef blobData;
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
|
|
switch (recordID) {
|
|
#define TYPE(TYPE_ID) \
|
|
case decls_block::detail::TypeRecords::TYPE_ID##_TYPE: { \
|
|
auto result = decls_block::detail::TypeRecordDispatch< \
|
|
decls_block::detail::TypeRecords::TYPE_ID##_TYPE>:: \
|
|
deserialize(*this, scratch, blobData); \
|
|
if (!result) \
|
|
return result; \
|
|
typeOrOffset = result.get(); \
|
|
} \
|
|
break;
|
|
#include "DeclTypeRecordNodes.def"
|
|
#undef TYPE
|
|
default:
|
|
// We don't know how to deserialize this kind of type.
|
|
return diagnoseFatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
}
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
PrettyStackTraceType trace(getContext(), "deserializing", typeOrOffset.get());
|
|
if (typeOrOffset.get()->hasError() && !allowCompilerErrors()) {
|
|
typeOrOffset.get()->dump(llvm::errs());
|
|
llvm_unreachable("deserialization produced an invalid type "
|
|
"(rdar://problem/30382791)");
|
|
}
|
|
#endif
|
|
|
|
return typeOrOffset.get();
|
|
}
|
|
|
|
namespace {
|
|
|
|
class SwiftToClangBasicReader :
|
|
public swift::DataStreamBasicReader<SwiftToClangBasicReader> {
|
|
|
|
ModuleFile &MF;
|
|
ClangModuleLoader &ClangLoader;
|
|
ArrayRef<uint64_t> Record;
|
|
|
|
public:
|
|
SwiftToClangBasicReader(ModuleFile &MF, ClangModuleLoader &clangLoader,
|
|
ArrayRef<uint64_t> record)
|
|
: DataStreamBasicReader(clangLoader.getClangASTContext()),
|
|
MF(MF), ClangLoader(clangLoader), Record(record) {}
|
|
|
|
uint64_t readUInt64() {
|
|
uint64_t value = Record[0];
|
|
Record = Record.drop_front();
|
|
return value;
|
|
}
|
|
|
|
Identifier readSwiftIdentifier() {
|
|
return MF.getIdentifier(IdentifierID(readUInt64()));
|
|
}
|
|
|
|
clang::IdentifierInfo *readIdentifier() {
|
|
Identifier swiftIdent = readSwiftIdentifier();
|
|
return &getASTContext().Idents.get(swiftIdent.str());
|
|
}
|
|
|
|
clang::Stmt *readStmtRef() {
|
|
// Should only be allowed with null statements.
|
|
return nullptr;
|
|
}
|
|
|
|
clang::Decl *readDeclRef() {
|
|
uint64_t refKind = readUInt64();
|
|
|
|
// Null reference.
|
|
if (refKind == 0) return nullptr;
|
|
|
|
// Swift declaration.
|
|
if (refKind == 1) {
|
|
swift::Decl *swiftDecl = MF.getDecl(DeclID(readUInt64()));
|
|
return const_cast<clang::Decl*>(
|
|
ClangLoader.resolveStableSerializationPath(swiftDecl));
|
|
}
|
|
|
|
// External path.
|
|
if (refKind == 2) {
|
|
using ExternalPath = StableSerializationPath::ExternalPath;
|
|
ExternalPath path;
|
|
uint64_t length = readUInt64();
|
|
path.Path.reserve(length);
|
|
for (uint64_t i = 0; i != length; ++i) {
|
|
auto kind = getActualClangDeclPathComponentKind(readUInt64());
|
|
if (!kind) return nullptr;
|
|
Identifier name = ExternalPath::requiresIdentifier(*kind)
|
|
? readSwiftIdentifier()
|
|
: Identifier();
|
|
path.add(*kind, name);
|
|
}
|
|
return const_cast<clang::Decl*>(
|
|
ClangLoader.resolveStableSerializationPath(std::move(path)));
|
|
}
|
|
|
|
// Unknown kind?
|
|
return nullptr;
|
|
}
|
|
|
|
const clang::Attr *readAttr() {
|
|
auto rawKind = readUInt32();
|
|
if (!rawKind)
|
|
return nullptr;
|
|
|
|
auto name = readIdentifier();
|
|
auto scopeName = readIdentifier();
|
|
|
|
auto rangeStart = readSourceLocation();
|
|
auto rangeEnd = readSourceLocation();
|
|
auto scopeLoc = readSourceLocation();
|
|
|
|
auto parsedKind = readEnum<clang::AttributeCommonInfo::Kind>();
|
|
auto syntax = readEnum<clang::AttributeCommonInfo::Syntax>();
|
|
unsigned spellingListIndex = readUInt64();
|
|
|
|
bool isRegularKeywordAttribute = readBool();
|
|
|
|
clang::AttributeCommonInfo info(
|
|
name, clang::AttributeScopeInfo(scopeName, scopeLoc),
|
|
{rangeStart, rangeEnd}, parsedKind,
|
|
{syntax, spellingListIndex, /*IsAlignas=*/false,
|
|
isRegularKeywordAttribute});
|
|
|
|
bool isInherited = readBool();
|
|
bool isImplicit = readBool();
|
|
bool isPackExpansion = readBool();
|
|
StringRef attribute = MF.getIdentifierText(readUInt64());
|
|
|
|
auto *attr =
|
|
clang::SwiftAttrAttr::Create(getASTContext(), attribute.str(), info);
|
|
cast<clang::InheritableAttr>(attr)->setInherited(isInherited);
|
|
attr->setImplicit(isImplicit);
|
|
attr->setPackExpansion(isPackExpansion);
|
|
|
|
return attr;
|
|
}
|
|
|
|
// CountAttributedType is a clang type representing a pointer with
|
|
// a "counted_by" type attribute and DynamicRangePointerType is
|
|
// representing a "__ended_by" type attribute.
|
|
// TypeCoupledDeclRefInfo is used to hold information of a declaration
|
|
// referenced from an expression argument of "__counted_by(expr)" or
|
|
// "__ended_by(expr)".
|
|
// Nothing to be done for now as we currently don't import
|
|
// these types into Swift.
|
|
clang::TypeCoupledDeclRefInfo readTypeCoupledDeclRefInfo() {
|
|
llvm_unreachable("TypeCoupledDeclRefInfo shouldn't be reached from swift");
|
|
}
|
|
clang::SpirvOperand readHLSLSpirvOperand() {
|
|
llvm_unreachable("SpirvOperand shouldn't be reached from swift");
|
|
}
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
llvm::Expected<const clang::Type *>
|
|
ModuleFile::getClangType(ClangTypeID TID) {
|
|
if (TID == 0)
|
|
return nullptr;
|
|
|
|
assert(TID <= ClangTypes.size() && "invalid type ID");
|
|
auto &typeOrOffset = ClangTypes[TID-1];
|
|
|
|
if (typeOrOffset.isComplete())
|
|
return typeOrOffset;
|
|
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (auto error =
|
|
diagnoseFatalIfNotSuccess(DeclTypeCursor.JumpToBit(typeOrOffset)))
|
|
return std::move(error);
|
|
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance());
|
|
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return diagnoseFatal();
|
|
|
|
SmallVector<uint64_t, 64> scratch;
|
|
StringRef blobData;
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
|
|
if (recordID != decls_block::CLANG_TYPE)
|
|
fatal(llvm::make_error<InvalidRecordKindError>(recordID));
|
|
|
|
auto &clangLoader = *getContext().getClangModuleLoader();
|
|
auto clangType =
|
|
SwiftToClangBasicReader(*this, clangLoader, scratch).readTypeRef()
|
|
.getTypePtr();
|
|
typeOrOffset = clangType;
|
|
return clangType;
|
|
}
|
|
|
|
Decl *ModuleFile::handleErrorAndSupplyMissingClassMember(
|
|
ASTContext &context, llvm::Error &&error,
|
|
ClassDecl *containingClass) const {
|
|
Decl *suppliedMissingMember = nullptr;
|
|
auto handleMissingClassMember = [&](const DeclDeserializationError &error) {
|
|
if (error.isDesignatedInitializer())
|
|
context.evaluator.cacheOutput(
|
|
HasMissingDesignatedInitializersRequest{containingClass}, true);
|
|
if (error.getNumberOfTableEntries() > 0)
|
|
containingClass->setHasMissingVTableEntries();
|
|
|
|
suppliedMissingMember = MissingMemberDecl::create(
|
|
context, containingClass, error.getName(),
|
|
error.getNumberOfTableEntries(),
|
|
error.needsFieldOffsetVectorEntry());
|
|
};
|
|
|
|
// Emit the diagnostics/remarks out of the ModularizationError
|
|
// wrapped in a TypeError (eg. coming from resolveCrossReference),
|
|
// which is otherwise just dropped but could help better understand
|
|
// C/C++ interop issues.
|
|
assert(context.LangOpts.EnableDeserializationRecovery);
|
|
auto handleModularizationError = [&](ModularizationError &error)
|
|
-> llvm::Error {
|
|
if (context.LangOpts.EnableModuleRecoveryRemarks)
|
|
error.diagnose(this, DiagnosticBehavior::Remark);
|
|
return llvm::Error::success();
|
|
};
|
|
auto handleTypeError = [&](TypeError &typeError) {
|
|
handleMissingClassMember(typeError);
|
|
typeError.diagnoseUnderlyingReason(handleModularizationError);
|
|
if (context.LangOpts.EnableModuleRecoveryRemarks)
|
|
typeError.diagnose(this);
|
|
};
|
|
llvm::handleAllErrors(std::move(error), handleTypeError,
|
|
handleMissingClassMember);
|
|
return suppliedMissingMember;
|
|
}
|
|
|
|
Decl *handleErrorAndSupplyMissingProtoMember(ASTContext &context,
|
|
llvm::Error &&error,
|
|
ProtocolDecl *containingProto) {
|
|
Decl *suppliedMissingMember = nullptr;
|
|
|
|
auto handleMissingProtocolMember =
|
|
[&](const DeclDeserializationError &error) {
|
|
assert(error.needsFieldOffsetVectorEntry() == 0);
|
|
|
|
if (error.getNumberOfTableEntries() > 0)
|
|
containingProto->setHasMissingRequirements(true);
|
|
|
|
suppliedMissingMember = MissingMemberDecl::create(
|
|
context, containingProto, error.getName(),
|
|
error.getNumberOfTableEntries(), 0);
|
|
};
|
|
llvm::handleAllErrors(std::move(error), handleMissingProtocolMember);
|
|
return suppliedMissingMember;
|
|
}
|
|
|
|
Decl *
|
|
ModuleFile::handleErrorAndSupplyMissingMiscMember(llvm::Error &&error) const {
|
|
diagnoseAndConsumeError(std::move(error));
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *
|
|
ModuleFile::handleErrorAndSupplyMissingMember(ASTContext &context,
|
|
Decl *container,
|
|
llvm::Error &&error) const {
|
|
// Drop the member if it had a problem.
|
|
// FIXME: Handle overridable members in class extensions too, someday.
|
|
if (auto *containingClass = dyn_cast<ClassDecl>(container)) {
|
|
return handleErrorAndSupplyMissingClassMember(context, std::move(error),
|
|
containingClass);
|
|
}
|
|
if (auto *containingProto = dyn_cast<ProtocolDecl>(container)) {
|
|
return handleErrorAndSupplyMissingProtoMember(context, std::move(error),
|
|
containingProto);
|
|
}
|
|
return handleErrorAndSupplyMissingMiscMember(std::move(error));
|
|
}
|
|
|
|
void ModuleFile::loadAllMembers(Decl *container, uint64_t contextData) {
|
|
PrettyStackTraceDecl trace("loading members for", container);
|
|
++NumMemberListsLoaded;
|
|
|
|
IterableDeclContext *IDC;
|
|
if (auto *nominal = dyn_cast<NominalTypeDecl>(container))
|
|
IDC = nominal;
|
|
else
|
|
IDC = cast<ExtensionDecl>(container);
|
|
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (diagnoseAndConsumeFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(contextData)))
|
|
return;
|
|
llvm::BitstreamEntry entry = fatalIfUnexpected(DeclTypeCursor.advance());
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
return diagnoseAndConsumeFatal();
|
|
|
|
SmallVector<uint64_t, 16> memberIDBuffer;
|
|
|
|
unsigned kind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(entry.ID, memberIDBuffer));
|
|
if (kind != decls_block::MEMBERS)
|
|
fatal(llvm::make_error<InvalidRecordKindError>(kind));
|
|
|
|
ArrayRef<uint64_t> rawMemberIDs;
|
|
decls_block::MembersLayout::readRecord(memberIDBuffer, rawMemberIDs);
|
|
|
|
if (rawMemberIDs.empty()) {
|
|
// No members; set the state of member deserialization to done.
|
|
if (!IDC->didDeserializeMembers())
|
|
IDC->setDeserializedMembers(true);
|
|
return;
|
|
}
|
|
SmallVector<Decl *, 16> members;
|
|
members.reserve(rawMemberIDs.size());
|
|
for (DeclID rawID : rawMemberIDs) {
|
|
Expected<Decl *> next = getDeclChecked(rawID);
|
|
if (next) {
|
|
assert(next.get() && "unchecked error deserializing next member");
|
|
members.push_back(next.get());
|
|
} else {
|
|
if (!getContext().LangOpts.EnableDeserializationRecovery)
|
|
fatal(next.takeError());
|
|
|
|
Decl *suppliedMissingMember = handleErrorAndSupplyMissingMember(
|
|
getContext(), container, next.takeError());
|
|
if (suppliedMissingMember)
|
|
members.push_back(suppliedMissingMember);
|
|
|
|
// Not all members can be discovered as missing
|
|
// members as checked above, so set the error bit
|
|
// here.
|
|
IDC->setHasDeserializeMemberError(true);
|
|
}
|
|
}
|
|
// Set the status of member deserialization to Done.
|
|
if (!IDC->didDeserializeMembers())
|
|
IDC->setDeserializedMembers(true);
|
|
|
|
for (auto member : members)
|
|
IDC->addMember(member);
|
|
|
|
if (auto *proto = dyn_cast<ProtocolDecl>(container)) {
|
|
PrettyStackTraceDecl trace("reading default witness table for", proto);
|
|
bool Err = readDefaultWitnessTable(proto);
|
|
assert(!Err && "unable to read default witness table");
|
|
(void)Err;
|
|
}
|
|
}
|
|
|
|
llvm::Error ModuleFile::consumeExpectedError(llvm::Error &&error) {
|
|
// Missing module errors are most likely caused by an
|
|
// implementation-only import hiding types and decls.
|
|
// rdar://problem/60291019
|
|
if (error.isA<XRefNonLoadedModuleError>() ||
|
|
error.isA<UnsafeDeserializationError>() ||
|
|
error.isA<ModularizationError>()) {
|
|
diagnoseAndConsumeError(std::move(error));
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
// Some of these errors may manifest as a TypeError with an
|
|
// XRefNonLoadedModuleError underneath. Catch those as well.
|
|
// rdar://66491720
|
|
if (error.isA<TypeError>()) {
|
|
auto errorInfo = takeErrorInfo(std::move(error));
|
|
auto *TE = static_cast<TypeError*>(errorInfo.get());
|
|
|
|
if (TE->underlyingReasonIsA<XRefNonLoadedModuleError>() ||
|
|
TE->underlyingReasonIsA<UnsafeDeserializationError>() ||
|
|
TE->underlyingReasonIsA<ModularizationError>()) {
|
|
diagnoseAndConsumeError(std::move(errorInfo));
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
return std::move(errorInfo);
|
|
}
|
|
|
|
return std::move(error);
|
|
}
|
|
|
|
void ModuleFile::diagnoseAndConsumeError(llvm::Error error) const {
|
|
auto &ctx = getContext();
|
|
if (ctx.LangOpts.EnableModuleRecoveryRemarks) {
|
|
error = diagnoseModularizationError(std::move(error),
|
|
DiagnosticBehavior::Remark);
|
|
// If error was already diagnosed it was also consumed.
|
|
if (!error)
|
|
return;
|
|
}
|
|
|
|
consumeError(std::move(error));
|
|
}
|
|
|
|
namespace {
|
|
class LazyConformanceLoaderInfo final
|
|
: llvm::TrailingObjects<LazyConformanceLoaderInfo,
|
|
ProtocolConformanceID> {
|
|
friend TrailingObjects;
|
|
|
|
size_t NumConformances;
|
|
size_t numTrailingObjects(OverloadToken<ProtocolConformanceID>) {
|
|
return NumConformances;
|
|
}
|
|
|
|
LazyConformanceLoaderInfo(ArrayRef<uint64_t> ids)
|
|
: NumConformances(ids.size()) {
|
|
auto *buffer = getTrailingObjects();
|
|
for (unsigned i = 0, e = ids.size(); i != e; ++i)
|
|
buffer[i] = ProtocolConformanceID(ids[i]);
|
|
}
|
|
|
|
public:
|
|
static LazyConformanceLoaderInfo *create(ModuleFile &mf,
|
|
ArrayRef<uint64_t> ids) {
|
|
size_t size = totalSizeToAlloc<ProtocolConformanceID>(ids.size());
|
|
size_t align = alignof(LazyConformanceLoaderInfo);
|
|
|
|
// TODO: maybe don't permanently allocate this?
|
|
void *memory = mf.getContext().Allocate(size, align);
|
|
return new (memory) LazyConformanceLoaderInfo(ids);
|
|
}
|
|
|
|
ArrayRef<ProtocolConformanceID> claim() {
|
|
// TODO: free the memory here (if it's not used in multiple places?)
|
|
return getTrailingObjects(NumConformances);
|
|
}
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
uint64_t ModuleFile::createLazyConformanceLoaderToken(ArrayRef<uint64_t> ids) {
|
|
if (ids.empty()) return 0;
|
|
|
|
auto info = LazyConformanceLoaderInfo::create(*this, ids);
|
|
return reinterpret_cast<uintptr_t>(info);
|
|
}
|
|
|
|
ArrayRef<ProtocolConformanceID>
|
|
ModuleFile::claimLazyConformanceLoaderToken(uint64_t token) {
|
|
if (token == 0) return {};
|
|
|
|
auto info = reinterpret_cast<LazyConformanceLoaderInfo*>(token);
|
|
return info->claim();
|
|
}
|
|
|
|
void
|
|
ModuleFile::loadAllConformances(const Decl *D, uint64_t contextData,
|
|
SmallVectorImpl<ProtocolConformance*> &conformances) {
|
|
PrettyStackTraceDecl trace("loading conformances for", D);
|
|
|
|
auto conformanceIDs = claimLazyConformanceLoaderToken(contextData);
|
|
for (auto conformanceID : conformanceIDs) {
|
|
auto conformance = getConformanceChecked(conformanceID);
|
|
|
|
if (!conformance) {
|
|
auto unconsumedError =
|
|
consumeExpectedError(conformance.takeError());
|
|
if (unconsumedError) {
|
|
// Ignore when we're not building a binary, it's just doing a best
|
|
// effort to produce *some* module anyway.
|
|
if (enableExtendedDeserializationRecovery())
|
|
diagnoseAndConsumeError(std::move(unconsumedError));
|
|
else
|
|
fatal(std::move(unconsumedError));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// FIXME: why is suppressing abstract conformances generally
|
|
// acceptable here?
|
|
if (conformance.get().isConcrete())
|
|
conformances.push_back(conformance.get().getConcrete());
|
|
}
|
|
}
|
|
|
|
Type
|
|
ModuleFile::loadAssociatedTypeDefault(const swift::AssociatedTypeDecl *ATD,
|
|
uint64_t contextData) {
|
|
return getType(contextData);
|
|
}
|
|
|
|
void
|
|
ModuleFile::finishOpaqueTypeDecl(OpaqueTypeDecl *opaqueDecl,
|
|
uint64_t contextData) {
|
|
auto &ctx = getAssociatedModule()->getASTContext();
|
|
auto *namingDecl = opaqueDecl->getNamingDecl();
|
|
|
|
using namespace decls_block;
|
|
PrettyStackTraceModuleFile traceModule(*this);
|
|
PrettyStackTraceDecl trace("finishing opaque result type ", namingDecl);
|
|
++NumOpaqueTypeDeclsCompleted;
|
|
|
|
// Find the underlying type substitutions record.
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (diagnoseAndConsumeFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(contextData)))
|
|
return;
|
|
llvm::BitstreamEntry entry = fatalIfUnexpected(DeclTypeCursor.advance());
|
|
assert(entry.Kind == llvm::BitstreamEntry::Record &&
|
|
"registered lazy loader incorrectly");
|
|
|
|
SubstitutionMapID underlyingTypeSubsID;
|
|
SmallVector<uint64_t, 16> scratch;
|
|
|
|
unsigned kind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(entry.ID, scratch));
|
|
if (kind != UNDERLYING_SUBSTITUTION)
|
|
fatal(llvm::make_error<InvalidRecordKindError>(kind,
|
|
"registered lazy loader incorrectly"));
|
|
|
|
UnderlyingSubstitutionLayout::readRecord(scratch, underlyingTypeSubsID);
|
|
|
|
auto subMapOrError = getSubstitutionMapChecked(underlyingTypeSubsID);
|
|
if (!subMapOrError) {
|
|
// If the underlying type references internal details, ignore it.
|
|
diagnoseAndConsumeError(subMapOrError.takeError());
|
|
return;
|
|
}
|
|
|
|
// Check whether there are any conditionally available substitutions.
|
|
// If there are, it means that "unique" we just read is a universally
|
|
// available substitution.
|
|
SmallVector<OpaqueTypeDecl::ConditionallyAvailableSubstitutions *>
|
|
limitedAvailability;
|
|
|
|
deserializeConditionalSubstitutions(limitedAvailability);
|
|
|
|
if (limitedAvailability.empty()) {
|
|
opaqueDecl->setUniqueUnderlyingTypeSubstitutions(subMapOrError.get());
|
|
} else {
|
|
limitedAvailability.push_back(
|
|
OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
|
|
ctx,
|
|
{AvailabilityQuery::universallyConstant(
|
|
/*value=*/true)},
|
|
subMapOrError.get()));
|
|
|
|
opaqueDecl->setConditionallyAvailableSubstitutions(limitedAvailability);
|
|
}
|
|
}
|
|
|
|
void ModuleFile::deserializeConditionalSubstitutions(
|
|
SmallVectorImpl<OpaqueTypeDecl::ConditionallyAvailableSubstitutions *>
|
|
&limitedAvailability) {
|
|
auto &ctx = getAssociatedModule()->getASTContext();
|
|
|
|
SmallVector<uint64_t, 4> scratch;
|
|
StringRef blobData;
|
|
|
|
while (true) {
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
break;
|
|
|
|
scratch.clear();
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != decls_block::CONDITIONAL_SUBSTITUTION)
|
|
break;
|
|
|
|
SubstitutionMapID substitutionMapRef;
|
|
|
|
decls_block::ConditionalSubstitutionLayout::readRecord(
|
|
scratch, substitutionMapRef);
|
|
|
|
SmallVector<AvailabilityQuery, 2> queries;
|
|
deserializeConditionalSubstitutionAvailabilityQueries(queries);
|
|
|
|
if (queries.empty())
|
|
return diagnoseAndConsumeFatal();
|
|
|
|
auto subMapOrError = getSubstitutionMapChecked(substitutionMapRef);
|
|
if (!subMapOrError)
|
|
return diagnoseAndConsumeFatal();
|
|
|
|
limitedAvailability.push_back(
|
|
OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
|
|
ctx, queries, subMapOrError.get()));
|
|
}
|
|
}
|
|
|
|
void ModuleFile::deserializeConditionalSubstitutionAvailabilityQueries(
|
|
SmallVectorImpl<AvailabilityQuery> &queries) {
|
|
using namespace decls_block;
|
|
|
|
auto &ctx = getAssociatedModule()->getASTContext();
|
|
|
|
SmallVector<uint64_t, 4> scratch;
|
|
StringRef blobData;
|
|
|
|
// FIXME: [availability] Support arbitrary domains (rdar://156513787).
|
|
auto domain = ctx.getTargetAvailabilityDomain();
|
|
ASSERT(domain.isPlatform());
|
|
|
|
while (true) {
|
|
llvm::BitstreamEntry entry =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (entry.Kind != llvm::BitstreamEntry::Record)
|
|
break;
|
|
|
|
scratch.clear();
|
|
|
|
unsigned recordID = fatalIfUnexpected(
|
|
DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
|
|
if (recordID != decls_block::CONDITIONAL_SUBSTITUTION_COND)
|
|
break;
|
|
|
|
bool isUnavailability;
|
|
DEF_VER_TUPLE_PIECES(version);
|
|
|
|
ConditionalSubstitutionConditionLayout::readRecord(
|
|
scratch, isUnavailability, LIST_VER_TUPLE_PIECES(version));
|
|
|
|
llvm::VersionTuple version;
|
|
DECODE_VER_TUPLE(version);
|
|
|
|
queries.push_back(AvailabilityQuery::dynamic(
|
|
domain, AvailabilityRange(version), std::nullopt)
|
|
.asUnavailable(isUnavailability));
|
|
}
|
|
}
|
|
|
|
ValueDecl *ModuleFile::loadDynamicallyReplacedFunctionDecl(
|
|
const DynamicReplacementAttr *DRA, uint64_t contextData) {
|
|
return cast<ValueDecl>(getDecl(contextData));
|
|
}
|
|
|
|
AbstractFunctionDecl *
|
|
ModuleFile::loadReferencedFunctionDecl(const DerivativeAttr *DA,
|
|
uint64_t contextData) {
|
|
return cast<AbstractFunctionDecl>(getDecl(contextData));
|
|
}
|
|
|
|
ValueDecl *ModuleFile::loadTargetFunctionDecl(
|
|
const AbstractSpecializeAttr *attr,
|
|
uint64_t contextData) {
|
|
if (contextData == 0)
|
|
return nullptr;
|
|
return cast<AbstractFunctionDecl>(getDecl(contextData));
|
|
}
|
|
|
|
Type ModuleFile::loadTypeEraserType(const TypeEraserAttr *TRA,
|
|
uint64_t contextData) {
|
|
return getType(contextData);
|
|
}
|
|
|
|
void ModuleFile::finishNormalConformance(NormalProtocolConformance *conformance,
|
|
uint64_t contextData) {
|
|
using namespace decls_block;
|
|
PrettyStackTraceModuleFile traceModule(*this);
|
|
PrettyStackTraceConformance trace("finishing conformance for",
|
|
conformance);
|
|
++NumNormalProtocolConformancesCompleted;
|
|
|
|
assert(conformance->isComplete());
|
|
|
|
conformance->setState(ProtocolConformanceState::Incomplete);
|
|
SWIFT_DEFER { conformance->setState(ProtocolConformanceState::Complete); };
|
|
|
|
// Find the conformance record.
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (diagnoseAndConsumeFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(contextData)))
|
|
return;
|
|
llvm::BitstreamEntry entry = fatalIfUnexpected(DeclTypeCursor.advance());
|
|
assert(entry.Kind == llvm::BitstreamEntry::Record &&
|
|
"registered lazy loader incorrectly");
|
|
|
|
DeclID protoID;
|
|
DeclContextID contextID;
|
|
TypeID globalActorTypeID;
|
|
unsigned valueCount, typeCount, conformanceCount, rawOptions;
|
|
ArrayRef<uint64_t> rawIDs;
|
|
SmallVector<uint64_t, 16> scratch;
|
|
|
|
unsigned kind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(entry.ID, scratch));
|
|
if (kind != NORMAL_PROTOCOL_CONFORMANCE)
|
|
fatal(llvm::make_error<InvalidRecordKindError>(kind,
|
|
"registered lazy loader incorrectly"));
|
|
|
|
NormalProtocolConformanceLayout::readRecord(
|
|
scratch, protoID, contextID, typeCount, valueCount, conformanceCount,
|
|
rawOptions, globalActorTypeID, rawIDs);
|
|
|
|
const ProtocolDecl *proto = conformance->getProtocol();
|
|
|
|
// Read requirement signature conformances.
|
|
SmallVector<ProtocolConformanceRef, 4> reqConformances;
|
|
for (auto conformanceID : rawIDs.slice(0, conformanceCount)) {
|
|
auto maybeConformance = getConformanceChecked(conformanceID);
|
|
if (maybeConformance) {
|
|
reqConformances.push_back(maybeConformance.get());
|
|
} else if (getContext().LangOpts.EnableDeserializationRecovery) {
|
|
// If a conformance is missing, mark the whole protocol conformance
|
|
// as invalid. Something is broken with the context.
|
|
conformance->setInvalid();
|
|
|
|
llvm::Error error = maybeConformance.takeError();
|
|
if (error.isA<ConformanceXRefError>()) {
|
|
// The error was printed along with creating the ConformanceXRefError.
|
|
// Print the note here explaining the side effect.
|
|
std::string typeStr = conformance->getType()->getString();
|
|
auto &diags = getContext().Diags;
|
|
diags.diagnose(getSourceLoc(),
|
|
diag::modularization_issue_conformance_xref_note,
|
|
typeStr, proto->getName());
|
|
|
|
consumeError(std::move(error));
|
|
return;
|
|
}
|
|
|
|
// Leave it up to the centralized service to report other errors.
|
|
diagnoseAndConsumeError(std::move(error));
|
|
return;
|
|
} else {
|
|
fatal(maybeConformance.takeError());
|
|
}
|
|
}
|
|
|
|
if (proto->isObjC() && getContext().LangOpts.EnableDeserializationRecovery) {
|
|
// Don't crash if inherited protocols are added or removed.
|
|
// This is limited to Objective-C protocols because we know their only
|
|
// conformance requirements are on Self. This isn't actually a /safe/ change
|
|
// even in Objective-C, but we mostly just don't want to crash.
|
|
|
|
llvm::SmallDenseMap<ProtocolDecl *, ProtocolConformanceRef, 16>
|
|
conformancesForProtocols;
|
|
for (auto nextConformance : reqConformances) {
|
|
ProtocolDecl *confProto = nextConformance.getProtocol();
|
|
conformancesForProtocols[confProto] = nextConformance;
|
|
}
|
|
|
|
// Reset and rebuild the conformances from what we have.
|
|
reqConformances.clear();
|
|
for (const auto &req : proto->getRequirementSignature().getRequirements()) {
|
|
if (req.getKind() != RequirementKind::Conformance)
|
|
continue;
|
|
ASSERT(req.getFirstType()->isEqual(proto->getSelfInterfaceType()));
|
|
ProtocolDecl *proto = req.getProtocolDecl();
|
|
auto iter = conformancesForProtocols.find(proto);
|
|
if (iter != conformancesForProtocols.end()) {
|
|
reqConformances.push_back(iter->getSecond());
|
|
} else {
|
|
// Put in an abstract conformance as a placeholder. This is a lie, but
|
|
// there's not much better we can do. We're relying on the fact that
|
|
// the rest of the compiler doesn't actually need to check the
|
|
// conformance to an Objective-C protocol for anything important.
|
|
// There are no associated types and we don't emit a Swift conformance
|
|
// record.
|
|
reqConformances.push_back(ProtocolConformanceRef::forAbstract(
|
|
conformance->getType(), proto));
|
|
}
|
|
}
|
|
} else {
|
|
auto isConformanceReq = [](const Requirement &req) {
|
|
return req.getKind() == RequirementKind::Conformance;
|
|
};
|
|
auto requirements = proto->getRequirementSignature().getRequirements();
|
|
unsigned int conformanceRequirementCount =
|
|
llvm::count_if(requirements, isConformanceReq);
|
|
if (conformanceCount != conformanceRequirementCount) {
|
|
// Mismatch between the number of loaded conformances and the expected
|
|
// requirements. One or the other likely comes from a stale module.
|
|
|
|
if (!enableExtendedDeserializationRecovery()) {
|
|
// Error and print full context for visual inspection.
|
|
ASTContext &ctx = getContext();
|
|
std::string typeStr = conformance->getType()->getString();
|
|
ctx.Diags.diagnose(getSourceLoc(),
|
|
diag::modularization_issue_conformance_error,
|
|
typeStr, proto->getName(), conformanceCount,
|
|
conformanceRequirementCount);
|
|
ctx.Diags.flushConsumers();
|
|
|
|
// Print context to stderr.
|
|
PrintOptions Opts;
|
|
llvm::errs() << "Requirements seen by this invocation:\n";
|
|
for (auto req: requirements) {
|
|
req.print(llvm::errs(), Opts);
|
|
llvm::errs() << "\n";
|
|
}
|
|
|
|
llvm::errs() << "\nConformances written in the swiftmodule:\n";
|
|
for (auto req: reqConformances) {
|
|
req.print(llvm::errs());
|
|
llvm::errs() << "\n";
|
|
}
|
|
}
|
|
|
|
conformance->setInvalid();
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (unsigned index : indices(reqConformances)) {
|
|
conformance->setAssociatedConformance(index, reqConformances[index]);
|
|
}
|
|
|
|
ArrayRef<uint64_t>::iterator rawIDIter = rawIDs.begin() + conformanceCount;
|
|
|
|
TypeWitnessMap typeWitnesses;
|
|
while (typeCount--) {
|
|
// FIXME: We don't actually want to allocate an archetype here; we just
|
|
// want to get an access path within the protocol.
|
|
auto first = cast<AssociatedTypeDecl>(getDecl(*rawIDIter++));
|
|
auto secondOrError = getTypeChecked(*rawIDIter++);
|
|
Type second;
|
|
if (secondOrError) {
|
|
second = *secondOrError;
|
|
} else if (getContext().LangOpts.EnableDeserializationRecovery) {
|
|
second = ErrorType::get(getContext());
|
|
diagnoseAndConsumeError(secondOrError.takeError());
|
|
} else {
|
|
fatal(secondOrError.takeError());
|
|
}
|
|
auto thirdOrError = getDeclChecked(*rawIDIter++);
|
|
TypeDecl *third;
|
|
if (thirdOrError) {
|
|
third = cast_or_null<TypeDecl>(*thirdOrError);
|
|
} else if (getContext().LangOpts.EnableDeserializationRecovery) {
|
|
third = nullptr;
|
|
diagnoseAndConsumeError(thirdOrError.takeError());
|
|
} else {
|
|
fatal(thirdOrError.takeError());
|
|
}
|
|
if (isa_and_nonnull<TypeAliasDecl>(third) &&
|
|
third->getModuleContext() != getAssociatedModule() &&
|
|
!third->getDeclaredInterfaceType()->isEqual(second)) {
|
|
// Conservatively drop references to typealiases in other modules
|
|
// that may have changed. This may also drop references to typealiases
|
|
// that /haven't/ changed but just happen to have generics in them, but
|
|
// in practice having a declaration here isn't actually required by the
|
|
// rest of the compiler.
|
|
third = nullptr;
|
|
}
|
|
typeWitnesses[first] = {second, third};
|
|
}
|
|
assert(rawIDIter <= rawIDs.end() && "read too much");
|
|
|
|
// Set type witnesses.
|
|
for (auto typeWitness : typeWitnesses) {
|
|
conformance->setTypeWitness(typeWitness.first,
|
|
typeWitness.second.getWitnessType(),
|
|
typeWitness.second.getWitnessDecl());
|
|
}
|
|
|
|
// An imported requirement may have changed type between Swift versions.
|
|
// In this situation we need to do a post-pass to fill in missing
|
|
// requirements with opaque witnesses.
|
|
bool needToFillInOpaqueValueWitnesses = false;
|
|
while (valueCount--) {
|
|
ValueDecl *req;
|
|
|
|
auto trySetWitness = [&](Witness w) {
|
|
if (req)
|
|
conformance->setWitness(req, w);
|
|
};
|
|
|
|
auto deserializedReq = getDeclChecked(*rawIDIter++);
|
|
if (deserializedReq) {
|
|
req = cast_or_null<ValueDecl>(*deserializedReq);
|
|
} else if (getContext().LangOpts.EnableDeserializationRecovery) {
|
|
diagnoseAndConsumeError(deserializedReq.takeError());
|
|
req = nullptr;
|
|
needToFillInOpaqueValueWitnesses = true;
|
|
} else {
|
|
fatal(deserializedReq.takeError());
|
|
}
|
|
|
|
bool isOpaque = false;
|
|
ValueDecl *witness;
|
|
auto deserializedWitness = getDeclChecked(*rawIDIter++);
|
|
if (deserializedWitness) {
|
|
witness = cast_or_null<ValueDecl>(*deserializedWitness);
|
|
// Across language compatibility versions, the witnessing decl may have
|
|
// changed its signature as seen by the current compatibility version.
|
|
// In that case, we want the conformance to still be available, but
|
|
// we can't make use of the relationship to the underlying decl.
|
|
} else if (getContext().LangOpts.EnableDeserializationRecovery) {
|
|
diagnoseAndConsumeError(deserializedWitness.takeError());
|
|
isOpaque = true;
|
|
witness = nullptr;
|
|
} else {
|
|
fatal(deserializedWitness.takeError());
|
|
}
|
|
|
|
if (!witness && !isOpaque) {
|
|
trySetWitness(Witness());
|
|
continue;
|
|
}
|
|
|
|
auto trySetOpaqueWitness = [&]{
|
|
if (!req)
|
|
return;
|
|
|
|
conformance->setWitness(req, Witness::forOpaque(req));
|
|
};
|
|
|
|
// Witness substitutions.
|
|
auto witnessSubstitutions = getSubstitutionMapChecked(*rawIDIter++);
|
|
if (!witnessSubstitutions) {
|
|
// Missing module errors are most likely caused by an
|
|
// implementation-only import hiding types and decls.
|
|
// rdar://problem/52837313. Ignore completely if allowing
|
|
// errors - we're just doing a best effort to create the
|
|
// module in that case.
|
|
if (witnessSubstitutions.errorIsA<XRefNonLoadedModuleError>() ||
|
|
witnessSubstitutions.errorIsA<UnsafeDeserializationError>() ||
|
|
allowCompilerErrors()) {
|
|
diagnoseAndConsumeError(witnessSubstitutions.takeError());
|
|
isOpaque = true;
|
|
}
|
|
else
|
|
fatal(witnessSubstitutions.takeError());
|
|
}
|
|
|
|
// Determine whether we need to enter the actor isolation of the witness.
|
|
std::optional<ActorIsolation> enterIsolation;
|
|
if (*rawIDIter++ && witness) {
|
|
enterIsolation = getActorIsolation(witness);
|
|
}
|
|
|
|
// Handle opaque witnesses that couldn't be deserialized.
|
|
if (isOpaque) {
|
|
trySetOpaqueWitness();
|
|
continue;
|
|
}
|
|
|
|
// Set the witness.
|
|
trySetWitness(
|
|
Witness::forDeserialized(
|
|
witness, witnessSubstitutions.get(), enterIsolation));
|
|
}
|
|
assert(rawIDIter <= rawIDs.end() && "read too much");
|
|
|
|
// Fill in opaque value witnesses if we need to.
|
|
if (needToFillInOpaqueValueWitnesses) {
|
|
for (auto member : proto->getMembers()) {
|
|
// We only care about non-associated-type requirements.
|
|
auto valueMember = dyn_cast<ValueDecl>(member);
|
|
if (!valueMember || !valueMember->isProtocolRequirement()
|
|
|| isa<AssociatedTypeDecl>(valueMember))
|
|
continue;
|
|
|
|
if (!conformance->hasWitness(valueMember))
|
|
conformance->setWitness(valueMember, Witness::forOpaque(valueMember));
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModuleFile::loadRequirementSignature(const ProtocolDecl *decl,
|
|
uint64_t contextData,
|
|
SmallVectorImpl<Requirement> &reqs,
|
|
SmallVectorImpl<ProtocolTypeAlias> &typeAliases) {
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (diagnoseAndConsumeFatalIfNotSuccess(
|
|
(DeclTypeCursor.JumpToBit(contextData))))
|
|
return;
|
|
readRequirementSignature(reqs, typeAliases, DeclTypeCursor);
|
|
}
|
|
|
|
void ModuleFile::loadAssociatedTypes(const ProtocolDecl *decl,
|
|
uint64_t contextData,
|
|
SmallVectorImpl<AssociatedTypeDecl *> &assocTypes) {
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (diagnoseAndConsumeFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(contextData)))
|
|
return;
|
|
readAssociatedTypes(assocTypes, DeclTypeCursor);
|
|
}
|
|
|
|
void ModuleFile::loadPrimaryAssociatedTypes(const ProtocolDecl *decl,
|
|
uint64_t contextData,
|
|
SmallVectorImpl<AssociatedTypeDecl *> &assocTypes) {
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
if (diagnoseAndConsumeFatalIfNotSuccess(
|
|
DeclTypeCursor.JumpToBit(contextData)))
|
|
return;
|
|
readPrimaryAssociatedTypes(assocTypes, DeclTypeCursor);
|
|
}
|
|
|
|
static std::optional<ForeignErrorConvention::Kind>
|
|
decodeRawStableForeignErrorConventionKind(uint8_t kind) {
|
|
switch (kind) {
|
|
case static_cast<uint8_t>(ForeignErrorConventionKind::ZeroResult):
|
|
return ForeignErrorConvention::ZeroResult;
|
|
case static_cast<uint8_t>(ForeignErrorConventionKind::NonZeroResult):
|
|
return ForeignErrorConvention::NonZeroResult;
|
|
case static_cast<uint8_t>(ForeignErrorConventionKind::ZeroPreservedResult):
|
|
return ForeignErrorConvention::ZeroPreservedResult;
|
|
case static_cast<uint8_t>(ForeignErrorConventionKind::NilResult):
|
|
return ForeignErrorConvention::NilResult;
|
|
case static_cast<uint8_t>(ForeignErrorConventionKind::NonNilError):
|
|
return ForeignErrorConvention::NonNilError;
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
std::optional<StringRef> ModuleFile::maybeReadInlinableBodyText() {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 8> scratch;
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
StringRef blobData;
|
|
|
|
llvm::BitstreamEntry next =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (next.Kind != llvm::BitstreamEntry::Record)
|
|
return std::nullopt;
|
|
|
|
unsigned recKind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(next.ID, scratch, &blobData));
|
|
if (recKind != INLINABLE_BODY_TEXT)
|
|
return std::nullopt;
|
|
|
|
restoreOffset.reset();
|
|
return blobData;
|
|
}
|
|
|
|
std::optional<ForeignErrorConvention>
|
|
ModuleFile::maybeReadForeignErrorConvention() {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 8> scratch;
|
|
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
|
|
llvm::BitstreamEntry next =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (next.Kind != llvm::BitstreamEntry::Record)
|
|
return std::nullopt;
|
|
|
|
unsigned recKind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(next.ID, scratch));
|
|
switch (recKind) {
|
|
case FOREIGN_ERROR_CONVENTION:
|
|
restoreOffset.reset();
|
|
break;
|
|
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
|
|
uint8_t rawKind;
|
|
bool isOwned;
|
|
bool isReplaced;
|
|
unsigned errorParameterIndex;
|
|
TypeID errorParameterTypeID;
|
|
TypeID resultTypeID;
|
|
ForeignErrorConventionLayout::readRecord(scratch, rawKind,
|
|
isOwned, isReplaced,
|
|
errorParameterIndex,
|
|
errorParameterTypeID,
|
|
resultTypeID);
|
|
|
|
ForeignErrorConvention::Kind kind;
|
|
if (auto optKind = decodeRawStableForeignErrorConventionKind(rawKind))
|
|
kind = *optKind;
|
|
else {
|
|
diagnoseAndConsumeFatal();
|
|
return std::nullopt;
|
|
}
|
|
|
|
Type errorParameterType = getType(errorParameterTypeID);
|
|
CanType canErrorParameterType;
|
|
if (errorParameterType)
|
|
canErrorParameterType = errorParameterType->getCanonicalType();
|
|
|
|
Type resultType = getType(resultTypeID);
|
|
CanType canResultType;
|
|
if (resultType)
|
|
canResultType = resultType->getCanonicalType();
|
|
|
|
auto owned = isOwned ? ForeignErrorConvention::IsOwned
|
|
: ForeignErrorConvention::IsNotOwned;
|
|
auto replaced = ForeignErrorConvention::IsReplaced_t(isOwned);
|
|
switch (kind) {
|
|
case ForeignErrorConvention::ZeroResult:
|
|
return ForeignErrorConvention::getZeroResult(errorParameterIndex,
|
|
owned, replaced,
|
|
canErrorParameterType,
|
|
canResultType);
|
|
|
|
case ForeignErrorConvention::NonZeroResult:
|
|
return ForeignErrorConvention::getNonZeroResult(errorParameterIndex,
|
|
owned, replaced,
|
|
canErrorParameterType,
|
|
canResultType);
|
|
|
|
case ForeignErrorConvention::ZeroPreservedResult:
|
|
return ForeignErrorConvention::getZeroPreservedResult(errorParameterIndex,
|
|
owned, replaced,
|
|
canErrorParameterType);
|
|
|
|
case ForeignErrorConvention::NilResult:
|
|
return ForeignErrorConvention::getNilResult(errorParameterIndex,
|
|
owned, replaced,
|
|
canErrorParameterType);
|
|
|
|
case ForeignErrorConvention::NonNilError:
|
|
return ForeignErrorConvention::getNonNilError(errorParameterIndex,
|
|
owned, replaced,
|
|
canErrorParameterType);
|
|
}
|
|
|
|
llvm_unreachable("Unhandled ForeignErrorConvention in switch.");
|
|
}
|
|
|
|
std::optional<ForeignAsyncConvention>
|
|
ModuleFile::maybeReadForeignAsyncConvention() {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 8> scratch;
|
|
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
|
|
llvm::BitstreamEntry next =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (next.Kind != llvm::BitstreamEntry::Record)
|
|
return std::nullopt;
|
|
|
|
unsigned recKind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(next.ID, scratch));
|
|
switch (recKind) {
|
|
case FOREIGN_ASYNC_CONVENTION:
|
|
restoreOffset.reset();
|
|
break;
|
|
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
|
|
TypeID completionHandlerTypeID;
|
|
unsigned completionHandlerParameterIndex;
|
|
unsigned rawErrorParameterIndex;
|
|
unsigned rawErrorFlagParameterIndex;
|
|
bool errorFlagPolarity;
|
|
ForeignAsyncConventionLayout::readRecord(scratch,
|
|
completionHandlerTypeID,
|
|
completionHandlerParameterIndex,
|
|
rawErrorParameterIndex,
|
|
rawErrorFlagParameterIndex,
|
|
errorFlagPolarity);
|
|
|
|
Type completionHandlerType = getType(completionHandlerTypeID);
|
|
CanType canCompletionHandlerType;
|
|
if (completionHandlerType)
|
|
canCompletionHandlerType = completionHandlerType->getCanonicalType();
|
|
|
|
// Decode the error and flag parameters.
|
|
std::optional<unsigned> completionHandlerErrorParamIndex;
|
|
if (rawErrorParameterIndex > 0)
|
|
completionHandlerErrorParamIndex = rawErrorParameterIndex - 1;
|
|
std::optional<unsigned> completionHandlerErrorFlagParamIndex;
|
|
if (rawErrorFlagParameterIndex > 0)
|
|
completionHandlerErrorFlagParamIndex = rawErrorFlagParameterIndex - 1;
|
|
|
|
return ForeignAsyncConvention(
|
|
canCompletionHandlerType, completionHandlerParameterIndex,
|
|
completionHandlerErrorParamIndex,
|
|
completionHandlerErrorFlagParamIndex,
|
|
errorFlagPolarity);
|
|
}
|
|
|
|
bool ModuleFile::maybeReadLifetimeDependenceRecord(
|
|
SmallVectorImpl<uint64_t> &scratch) {
|
|
using namespace decls_block;
|
|
|
|
BCOffsetRAII restoreOffset(DeclTypeCursor);
|
|
|
|
llvm::BitstreamEntry next =
|
|
fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
|
|
if (next.Kind != llvm::BitstreamEntry::Record)
|
|
return false;
|
|
|
|
unsigned recKind =
|
|
fatalIfUnexpected(DeclTypeCursor.readRecord(next.ID, scratch));
|
|
switch (recKind) {
|
|
case LIFETIME_DEPENDENCE:
|
|
restoreOffset.reset();
|
|
break;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
std::optional<LifetimeDependenceInfo>
|
|
ModuleFile::maybeReadLifetimeDependence() {
|
|
using namespace decls_block;
|
|
|
|
SmallVector<uint64_t, 8> scratch;
|
|
if (!maybeReadLifetimeDependenceRecord(scratch)) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
unsigned targetIndex;
|
|
unsigned paramIndicesLength;
|
|
bool isImmortal;
|
|
bool hasInheritLifetimeParamIndices;
|
|
bool hasScopeLifetimeParamIndices;
|
|
bool hasAddressableParamIndices;
|
|
ArrayRef<uint64_t> lifetimeDependenceData;
|
|
LifetimeDependenceLayout::readRecord(
|
|
scratch, targetIndex, paramIndicesLength, isImmortal,
|
|
hasInheritLifetimeParamIndices, hasScopeLifetimeParamIndices,
|
|
hasAddressableParamIndices, lifetimeDependenceData);
|
|
|
|
SmallBitVector inheritLifetimeParamIndices(paramIndicesLength, false);
|
|
SmallBitVector scopeLifetimeParamIndices(paramIndicesLength, false);
|
|
SmallBitVector addressableParamIndices(paramIndicesLength, false);
|
|
|
|
unsigned startIndex = 0;
|
|
auto pushData = [&](SmallBitVector &bits) {
|
|
for (unsigned i = 0; i < paramIndicesLength; i++) {
|
|
if (lifetimeDependenceData[startIndex + i]) {
|
|
bits.set(i);
|
|
}
|
|
}
|
|
startIndex += paramIndicesLength;
|
|
};
|
|
|
|
if (hasInheritLifetimeParamIndices) {
|
|
pushData(inheritLifetimeParamIndices);
|
|
}
|
|
if (hasScopeLifetimeParamIndices) {
|
|
pushData(scopeLifetimeParamIndices);
|
|
}
|
|
if (hasAddressableParamIndices) {
|
|
pushData(addressableParamIndices);
|
|
}
|
|
|
|
ASTContext &ctx = getContext();
|
|
return LifetimeDependenceInfo(
|
|
hasInheritLifetimeParamIndices
|
|
? IndexSubset::get(ctx, inheritLifetimeParamIndices)
|
|
: nullptr,
|
|
hasScopeLifetimeParamIndices
|
|
? IndexSubset::get(ctx, scopeLifetimeParamIndices)
|
|
: nullptr,
|
|
targetIndex, isImmortal,
|
|
hasAddressableParamIndices
|
|
? IndexSubset::get(ctx, addressableParamIndices)
|
|
: nullptr);
|
|
}
|