Skip to content

Commit 1cd636d

Browse files
tshortlitshortli
committed
Serialization: Encode custom availability domains.
When serializing `@available` attributes, if the attribute applies to a custom domain include enough information to deserialize the reference to that domain. Resolves rdar://138441265.
1 parent 0a81283 commit 1cd636d

File tree

15 files changed

+277
-97
lines changed

15 files changed

+277
-97
lines changed

‎include/swift/AST/AvailabilityDomain.h‎

Lines changed: 19 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,7 @@
3232
namespace swift {
3333
class ASTContext;
3434
class CustomAvailabilityDomain;
35+
class Decl;
3536
class DeclContext;
3637
class ModuleDecl;
3738

@@ -148,6 +149,11 @@ class AvailabilityDomain final {
148149
return AvailabilityDomain(Kind::Embedded);
149150
}
150151

152+
/// If `decl` represents an availability domain, returns the corresponding
153+
/// `AvailabilityDomain` value. Otherwise, returns `std::nullopt`.
154+
static std::optional<AvailabilityDomain> forCustom(Decl *decl,
155+
const ASTContext &ctx);
156+
151157
static AvailabilityDomain forCustom(const CustomAvailabilityDomain *domain) {
152158
return AvailabilityDomain(domain);
153159
}
@@ -236,6 +242,10 @@ class AvailabilityDomain final {
236242
/// Returns the string to use when printing an `@available` attribute.
237243
llvm::StringRef getNameForAttributePrinting() const;
238244

245+
/// Returns the decl that represents the domain, or `nullptr` if the domain
246+
/// does not have a decl.
247+
Decl *getDecl() const;
248+
239249
/// Returns the module that the domain belongs to, if it is a custom domain.
240250
ModuleDecl *getModule() const;
241251

@@ -307,24 +317,26 @@ class CustomAvailabilityDomain : public llvm::FoldingSetNode {
307317
Identifier name;
308318
Kind kind;
309319
ModuleDecl *mod;
320+
Decl *decl;
310321

311-
CustomAvailabilityDomain(Identifier name, ModuleDecl *mod, Kind kind);
322+
CustomAvailabilityDomain(Identifier name, Kind kind, ModuleDecl *mod,
323+
Decl *decl);
312324

313325
public:
314-
static const CustomAvailabilityDomain *get(StringRef name, ModuleDecl *mod,
315-
Kind kind, const ASTContext &ctx);
326+
static const CustomAvailabilityDomain *get(StringRef name, Kind kind,
327+
ModuleDecl *mod, Decl *decl,
328+
const ASTContext &ctx);
316329

317330
Identifier getName() const { return name; }
318331
Kind getKind() const { return kind; }
319332
ModuleDecl *getModule() const { return mod; }
333+
Decl *getDecl() const { return decl; }
320334

321335
/// Uniquing for `ASTContext`.
322336
static void Profile(llvm::FoldingSetNodeID &ID, Identifier name,
323-
ModuleDecl *mod, Kind kind);
337+
ModuleDecl *mod);
324338

325-
void Profile(llvm::FoldingSetNodeID &ID) const {
326-
Profile(ID, name, mod, kind);
327-
}
339+
void Profile(llvm::FoldingSetNodeID &ID) const { Profile(ID, name, mod); }
328340
};
329341

330342
/// Represents either a resolved availability domain or an identifier written

‎lib/AST/ASTContext.cpp‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5866,11 +5866,11 @@ const AvailabilityContext::Storage *AvailabilityContext::Storage::get(
58665866
}
58675867

58685868
const CustomAvailabilityDomain *
5869-
CustomAvailabilityDomain::get(StringRef name, ModuleDecl *mod, Kind kind,
5870-
const ASTContext &ctx) {
5869+
CustomAvailabilityDomain::get(StringRef name, Kind kind, ModuleDecl *mod,
5870+
Decl *decl, const ASTContext &ctx) {
58715871
auto identifier = ctx.getIdentifier(name);
58725872
llvm::FoldingSetNodeID id;
5873-
CustomAvailabilityDomain::Profile(id, identifier, mod, kind);
5873+
CustomAvailabilityDomain::Profile(id, identifier, mod);
58745874

58755875
auto &foldingSet = ctx.getImpl().CustomAvailabilityDomains;
58765876
void *insertPos;
@@ -5880,7 +5880,8 @@ CustomAvailabilityDomain::get(StringRef name, ModuleDecl *mod, Kind kind,
58805880

58815881
void *mem = ctx.Allocate(sizeof(CustomAvailabilityDomain),
58825882
alignof(CustomAvailabilityDomain));
5883-
auto *newNode = ::new (mem) CustomAvailabilityDomain(identifier, mod, kind);
5883+
auto *newNode =
5884+
::new (mem) CustomAvailabilityDomain(identifier, kind, mod, decl);
58845885
foldingSet.InsertNode(newNode, insertPos);
58855886

58865887
return newNode;

‎lib/AST/AvailabilityDomain.cpp‎

Lines changed: 62 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -17,10 +17,61 @@
1717
#include "swift/AST/Module.h"
1818
#include "swift/AST/TypeCheckRequests.h"
1919
#include "swift/Basic/Assertions.h"
20+
#include "clang/AST/ASTContext.h"
21+
#include "clang/AST/Decl.h"
2022
#include "llvm/ADT/StringSwitch.h"
2123

2224
using namespace swift;
2325

26+
CustomAvailabilityDomain::Kind
27+
getCustomDomainKind(clang::FeatureAvailKind featureAvailKind) {
28+
switch (featureAvailKind) {
29+
case clang::FeatureAvailKind::None:
30+
llvm_unreachable("unexpected kind");
31+
case clang::FeatureAvailKind::Available:
32+
return CustomAvailabilityDomain::Kind::Enabled;
33+
case clang::FeatureAvailKind::Unavailable:
34+
return CustomAvailabilityDomain::Kind::Disabled;
35+
case clang::FeatureAvailKind::Dynamic:
36+
return CustomAvailabilityDomain::Kind::Dynamic;
37+
}
38+
}
39+
40+
static const CustomAvailabilityDomain *
41+
customDomainForClangDecl(Decl *decl, const ASTContext &ctx) {
42+
auto *clangDecl = decl->getClangDecl();
43+
ASSERT(clangDecl);
44+
45+
auto featureInfo = clangDecl->getASTContext().getFeatureAvailInfo(
46+
const_cast<clang::Decl *>(clangDecl));
47+
48+
// Ensure the decl actually represents an availability domain.
49+
if (featureInfo.first.empty())
50+
return nullptr;
51+
52+
if (featureInfo.second.Kind == clang::FeatureAvailKind::None)
53+
return nullptr;
54+
55+
return CustomAvailabilityDomain::get(
56+
featureInfo.first, getCustomDomainKind(featureInfo.second.Kind),
57+
decl->getModuleContext(), decl, ctx);
58+
}
59+
60+
std::optional<AvailabilityDomain>
61+
AvailabilityDomain::forCustom(Decl *decl, const ASTContext &ctx) {
62+
if (!decl)
63+
return std::nullopt;
64+
65+
if (decl->hasClangNode()) {
66+
if (auto *customDomain = customDomainForClangDecl(decl, ctx))
67+
return AvailabilityDomain::forCustom(customDomain);
68+
} else {
69+
// FIXME: [availability] Handle Swift availability domains decls.
70+
}
71+
72+
return std::nullopt;
73+
}
74+
2475
std::optional<AvailabilityDomain>
2576
AvailabilityDomain::builtinDomainForString(StringRef string,
2677
const DeclContext *declContext) {
@@ -166,6 +217,13 @@ llvm::StringRef AvailabilityDomain::getNameForAttributePrinting() const {
166217
}
167218
}
168219

220+
Decl *AvailabilityDomain::getDecl() const {
221+
if (auto *customDomain = getCustomDomain())
222+
return customDomain->getDecl();
223+
224+
return nullptr;
225+
}
226+
169227
ModuleDecl *AvailabilityDomain::getModule() const {
170228
if (auto customDomain = getCustomDomain())
171229
return customDomain->getModule();
@@ -268,19 +326,17 @@ bool StableAvailabilityDomainComparator::operator()(
268326
}
269327
}
270328

271-
CustomAvailabilityDomain::CustomAvailabilityDomain(Identifier name,
272-
ModuleDecl *mod, Kind kind)
273-
: name(name), kind(kind), mod(mod) {
329+
CustomAvailabilityDomain::CustomAvailabilityDomain(Identifier name, Kind kind,
330+
ModuleDecl *mod, Decl *decl)
331+
: name(name), kind(kind), mod(mod), decl(decl) {
274332
ASSERT(!name.empty());
275333
ASSERT(mod);
276334
}
277335

278336
void CustomAvailabilityDomain::Profile(llvm::FoldingSetNodeID &ID,
279-
Identifier name, ModuleDecl *mod,
280-
Kind kind) {
337+
Identifier name, ModuleDecl *mod) {
281338
ID.AddPointer(name.getAsOpaquePointer());
282339
ID.AddPointer(mod);
283-
ID.AddInteger(static_cast<unsigned>(kind));
284340
}
285341

286342
std::optional<AvailabilityDomain>

‎lib/ClangImporter/ClangImporter.cpp‎

Lines changed: 12 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -4115,49 +4115,28 @@ void ClangModuleUnit::lookupObjCMethods(
41154115
void ClangModuleUnit::lookupAvailabilityDomains(
41164116
Identifier identifier, SmallVectorImpl<AvailabilityDomain> &results) const {
41174117
auto domainName = identifier.str();
4118+
auto &ctx = getASTContext();
41184119
auto &clangASTContext = getClangASTContext();
41194120

4120-
// First, check the Clang AST context for a decl matching this availability
4121-
// domain name. If the domain was defined in the bridging header and that
4122-
// bridging header wasn't precompiled, this is where it will be found.
4123-
auto *domainDecl = clangASTContext.getFeatureAvailDecl(domainName);
4124-
if (!domainDecl) {
4125-
// Next, try external sources (.pcm/.pch).
4126-
auto externalSource = clangASTContext.getExternalSource();
4127-
if (externalSource)
4128-
domainDecl = dyn_cast_or_null<clang::VarDecl>(
4129-
externalSource->getAvailabilityDomainDecl(domainName));
4130-
}
4121+
auto domainInfo = clangASTContext.getFeatureAvailInfo(domainName);
4122+
if (domainInfo.Kind == clang::FeatureAvailKind::None)
4123+
return;
41314124

4132-
if (!domainDecl)
4125+
auto *varDecl = dyn_cast_or_null<clang::VarDecl>(domainInfo.Decl);
4126+
if (!varDecl)
41334127
return;
41344128

41354129
// The decl that was found may belong to a different Clang module.
4136-
if (domainDecl->getOwningModule() != getClangModule())
4130+
if (varDecl->getOwningModule() != getClangModule())
41374131
return;
41384132

4139-
// Construct a CustomAvailabilityDomain for the decl that was found.
4140-
auto featureInfo = clangASTContext.getFeatureAvailInfo(domainDecl);
4141-
if (featureInfo.first.empty())
4133+
auto *imported = ctx.getClangModuleLoader()->importDeclDirectly(varDecl);
4134+
if (!imported)
41424135
return;
41434136

4144-
auto getDomainKind = [](clang::FeatureAvailKind featureAvailKind) {
4145-
switch (featureAvailKind) {
4146-
case clang::FeatureAvailKind::None:
4147-
llvm_unreachable("unexpected kind");
4148-
case clang::FeatureAvailKind::Available:
4149-
return CustomAvailabilityDomain::Kind::Enabled;
4150-
case clang::FeatureAvailKind::Unavailable:
4151-
return CustomAvailabilityDomain::Kind::Disabled;
4152-
case clang::FeatureAvailKind::Dynamic:
4153-
return CustomAvailabilityDomain::Kind::Dynamic;
4154-
}
4155-
};
4156-
4157-
auto domain = AvailabilityDomain::forCustom(CustomAvailabilityDomain::get(
4158-
featureInfo.first, getParentModule(),
4159-
getDomainKind(featureInfo.second.Kind), getASTContext()));
4160-
results.push_back(domain);
4137+
auto customDomain = AvailabilityDomain::forCustom(imported, ctx);
4138+
ASSERT(customDomain);
4139+
results.push_back(*customDomain);
41614140
}
41624141

41634142
void ClangModuleUnit::collectLinkLibraries(

‎lib/Frontend/Frontend.cpp‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1409,7 +1409,8 @@ static void configureAvailabilityDomains(const ASTContext &ctx,
14091409
llvm::SmallDenseMap<Identifier, const CustomAvailabilityDomain *> domainMap;
14101410
auto createAndInsertDomain = [&](const std::string &name,
14111411
CustomAvailabilityDomain::Kind kind) {
1412-
auto *domain = CustomAvailabilityDomain::get(name, mainModule, kind, ctx);
1412+
auto *domain =
1413+
CustomAvailabilityDomain::get(name, kind, mainModule, nullptr, ctx);
14131414
bool inserted = domainMap.insert({domain->getName(), domain}).second;
14141415
ASSERT(inserted); // Domains must be unique.
14151416
};

‎lib/Serialization/Deserialization.cpp‎

Lines changed: 65 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -181,6 +181,8 @@ const char InvalidEnumValueError::ID = '\0';
181181
void InvalidEnumValueError::anchor() {}
182182
const char ConformanceXRefError::ID = '\0';
183183
void ConformanceXRefError::anchor() {}
184+
const char InavalidAvailabilityDomainError::ID = '\0';
185+
void InavalidAvailabilityDomainError::anchor() {}
184186

185187
/// Skips a single record in the bitstream.
186188
///
@@ -5727,35 +5729,79 @@ ModuleFile::getDeclChecked(
57275729
return declOrOffset;
57285730
}
57295731

5732+
static std::optional<AvailabilityDomainKind>
5733+
decodeDomainKind(uint8_t kind) {
5734+
switch (kind) {
5735+
case static_cast<uint8_t>(AvailabilityDomainKind::Universal):
5736+
return AvailabilityDomainKind::Universal;
5737+
case static_cast<uint8_t>(AvailabilityDomainKind::SwiftLanguage):
5738+
return AvailabilityDomainKind::SwiftLanguage;
5739+
case static_cast<uint8_t>(AvailabilityDomainKind::PackageDescription):
5740+
return AvailabilityDomainKind::PackageDescription;
5741+
case static_cast<uint8_t>(AvailabilityDomainKind::Embedded):
5742+
return AvailabilityDomainKind::Embedded;
5743+
case static_cast<uint8_t>(AvailabilityDomainKind::Platform):
5744+
return AvailabilityDomainKind::Platform;
5745+
case static_cast<uint8_t>(AvailabilityDomainKind::Custom):
5746+
return AvailabilityDomainKind::Custom;
5747+
default:
5748+
return std::nullopt;
5749+
}
5750+
}
5751+
5752+
static std::optional<AvailabilityDomain>
5753+
decodeAvailabilityDomain(AvailabilityDomainKind domainKind,
5754+
PlatformKind platformKind, Decl *decl,
5755+
const ASTContext &ctx) {
5756+
switch (domainKind) {
5757+
case AvailabilityDomainKind::Universal:
5758+
return AvailabilityDomain::forUniversal();
5759+
case AvailabilityDomainKind::SwiftLanguage:
5760+
return AvailabilityDomain::forSwiftLanguage();
5761+
case AvailabilityDomainKind::PackageDescription:
5762+
return AvailabilityDomain::forPackageDescription();
5763+
case AvailabilityDomainKind::Embedded:
5764+
return AvailabilityDomain::forEmbedded();
5765+
case AvailabilityDomainKind::Platform:
5766+
return AvailabilityDomain::forPlatform(platformKind);
5767+
case AvailabilityDomainKind::Custom:
5768+
return AvailabilityDomain::forCustom(decl, ctx);
5769+
}
5770+
}
5771+
57305772
Expected<AvailableAttr *>
57315773
DeclDeserializer::readAvailable_DECL_ATTR(SmallVectorImpl<uint64_t> &scratch,
57325774
StringRef blobData) {
57335775
bool isImplicit;
57345776
bool isUnavailable;
57355777
bool isDeprecated;
57365778
bool isNoAsync;
5737-
bool isPackageDescriptionVersionSpecific;
57385779
bool isSPI;
5739-
bool isForEmbedded;
5780+
uint8_t rawDomainKind;
5781+
unsigned rawPlatform;
5782+
DeclID domainDeclID;
57405783
DEF_VER_TUPLE_PIECES(Introduced);
57415784
DEF_VER_TUPLE_PIECES(Deprecated);
57425785
DEF_VER_TUPLE_PIECES(Obsoleted);
5743-
unsigned rawPlatform, messageSize, renameSize;
5786+
unsigned messageSize, renameSize;
57445787

57455788
// Decode the record, pulling the version tuple information.
57465789
serialization::decls_block::AvailableDeclAttrLayout::readRecord(
5747-
scratch, isImplicit, isUnavailable, isDeprecated, isNoAsync,
5748-
isPackageDescriptionVersionSpecific, isSPI, isForEmbedded,
5790+
scratch, isImplicit, isUnavailable, isDeprecated, isNoAsync, isSPI,
5791+
rawDomainKind, rawPlatform, domainDeclID,
57495792
LIST_VER_TUPLE_PIECES(Introduced), LIST_VER_TUPLE_PIECES(Deprecated),
5750-
LIST_VER_TUPLE_PIECES(Obsoleted), rawPlatform, messageSize,
5751-
renameSize);
5793+
LIST_VER_TUPLE_PIECES(Obsoleted), messageSize, renameSize);
5794+
5795+
auto maybeDomainKind = decodeDomainKind(rawDomainKind);
5796+
if (!maybeDomainKind)
5797+
return llvm::make_error<InvalidEnumValueError>(rawDomainKind, "AvailabilityDomainKind");
57525798

57535799
auto maybePlatform = platformFromUnsigned(rawPlatform);
57545800
if (!maybePlatform.has_value())
57555801
return llvm::make_error<InvalidEnumValueError>(rawPlatform, "PlatformKind");
57565802

5757-
PlatformKind platform = maybePlatform.value();
5758-
5803+
AvailabilityDomainKind domainKind = *maybeDomainKind;
5804+
PlatformKind platform = *maybePlatform;
57595805
StringRef message = blobData.substr(0, messageSize);
57605806
blobData = blobData.substr(messageSize);
57615807
StringRef rename = blobData.substr(0, renameSize);
@@ -5774,23 +5820,19 @@ DeclDeserializer::readAvailable_DECL_ATTR(SmallVectorImpl<uint64_t> &scratch,
57745820
else
57755821
kind = AvailableAttr::Kind::Default;
57765822

5777-
AvailabilityDomain domain;
5778-
if (platform != PlatformKind::none) {
5779-
domain = AvailabilityDomain::forPlatform(platform);
5780-
} else if (!Introduced.empty() || !Deprecated.empty() || !Obsoleted.empty()) {
5781-
domain = isPackageDescriptionVersionSpecific
5782-
? AvailabilityDomain::forPackageDescription()
5783-
: AvailabilityDomain::forSwiftLanguage();
5784-
} else if (isForEmbedded) {
5785-
domain = AvailabilityDomain::forEmbedded();
5786-
} else {
5787-
domain = AvailabilityDomain::forUniversal();
5823+
Decl *domainDecl = nullptr;
5824+
if (domainDeclID) {
5825+
SET_OR_RETURN_ERROR(domainDecl, MF.getDeclChecked(domainDeclID));
57885826
}
57895827

5828+
auto domain = decodeAvailabilityDomain(domainKind, platform, domainDecl, ctx);
5829+
if (!domain)
5830+
return llvm::make_error<InavalidAvailabilityDomainError>();
5831+
57905832
auto attr = new (ctx)
5791-
AvailableAttr(SourceLoc(), SourceRange(), domain, SourceLoc(), kind, message, rename,
5792-
Introduced, SourceRange(), Deprecated, SourceRange(),
5793-
Obsoleted, SourceRange(), isImplicit, isSPI);
5833+
AvailableAttr(SourceLoc(), SourceRange(), *domain, SourceLoc(), kind,
5834+
message, rename, Introduced, SourceRange(), Deprecated,
5835+
SourceRange(), Obsoleted, SourceRange(), isImplicit, isSPI);
57945836
return attr;
57955837
}
57965838

0 commit comments

Comments
 (0)