AST: Introduce "root" availability domains.

A root availability domain is a direct descendant of the universal availability
domain.

Author: tshortli

include/swift/AST/AvailabilityDomain.h

@@ -251,10 +251,14 @@ class AvailabilityDomain final {
   /// universal domain (`*`) is the bottom element.
   bool contains(const AvailabilityDomain &other) const;
 
-  /// Returns the root availability domain that this domain must be compatible
-  /// with. For example, macCatalyst and visionOS must both be ABI compatible
-  /// with iOS. The compatible domain must contain this domain.
-  AvailabilityDomain getABICompatibilityDomain() const;
+  /// Returns true for domains that are not contained by any domain other than
+  /// the universal domain.
+  bool isRoot() const;
+
+  /// Returns the root availability domain that contains this domain (see
+  /// `isRoot()`). For example, macCatalyst and visionOS are both ultimately
+  /// descendants of the iOS domain.
+  AvailabilityDomain getRootDomain() const;
 
   bool operator==(const AvailabilityDomain &other) const {
     return storage.getOpaqueValue() == other.storage.getOpaqueValue();

lib/AST/Availability.cpp

@@ -541,8 +541,10 @@ std::optional<SemanticAvailableAttr> Decl::getUnavailableAttr() const {
   return std::nullopt;
 }
 
+/// Returns the mutually exclusive root platform domains that must all be
+/// unavailable in order for a declaration to be unavailable at runtime.
 static llvm::SmallSetVector<AvailabilityDomain, 2>
-availabilityDomainsForABICompatibility(const ASTContext &ctx) {
+getRootTargetDomains(const ASTContext &ctx) {
   llvm::SmallSetVector<AvailabilityDomain, 2> domains;
 
   // Regardless of target platform, binaries built for Embedded do not require
@@ -551,10 +553,10 @@ availabilityDomainsForABICompatibility(const ASTContext &ctx) {
     return domains;
 
   if (auto targetDomain = AvailabilityDomain::forTargetPlatform(ctx))
-    domains.insert(targetDomain->getABICompatibilityDomain());
+    domains.insert(targetDomain->getRootDomain());
 
   if (auto variantDomain = AvailabilityDomain::forTargetVariantPlatform(ctx))
-    domains.insert(variantDomain->getABICompatibilityDomain());
+    domains.insert(variantDomain->getRootDomain());
 
   return domains;
 }
@@ -584,8 +586,8 @@ computeDeclRuntimeAvailability(const Decl *decl) {
     return DeclRuntimeAvailability::PotentiallyAvailable;
 
   auto &ctx = decl->getASTContext();
-  auto compatibilityDomains = availabilityDomainsForABICompatibility(ctx);
-  auto potentiallyAvailableDomains = compatibilityDomains;
+  auto rootTargetDomains = getRootTargetDomains(ctx);
+  auto remainingTargetDomains = rootTargetDomains;
 
   AvailabilityConstraintFlags flags;
 
@@ -606,20 +608,19 @@ computeDeclRuntimeAvailability(const Decl *decl) {
 
     // Check whether the constraint is from a relevant domain.
     auto domain = constraint.getDomain();
-    bool isCompabilityDomainDescendant =
-        llvm::find_if(compatibilityDomains,
-                      [&domain](AvailabilityDomain compatibilityDomain) {
-                        return compatibilityDomain.contains(domain);
-                      }) != compatibilityDomains.end();
+    bool isTargetDomain = rootTargetDomains.contains(domain);
 
-    if (!domain.isActive(ctx) && !isCompabilityDomainDescendant)
+    if (!domain.isActive(ctx) && !isTargetDomain)
       continue;
 
-    if (isCompabilityDomainDescendant) {
+    if (!domain.isRoot())
+      continue;
+
+    if (isTargetDomain) {
       // If the decl is still potentially available in some compatibility
       // domain, keep looking at the remaining constraints.
-      potentiallyAvailableDomains.remove(domain);
-      if (!potentiallyAvailableDomains.empty())
+      remainingTargetDomains.remove(domain);
+      if (!remainingTargetDomains.empty())
         continue;
     }
 

lib/AST/AvailabilityDomain.cpp

@@ -121,10 +121,8 @@ bool AvailabilityDomain::isActive(const ASTContext &ctx) const {
 bool AvailabilityDomain::isActiveForTargetPlatform(
     const ASTContext &ctx) const {
   if (isPlatform()) {
-    if (auto targetDomain = AvailabilityDomain::forTargetPlatform(ctx)) {
-      auto compatibleDomain = targetDomain->getABICompatibilityDomain();
-      return compatibleDomain.contains(*this);
-    }
+    if (auto targetDomain = AvailabilityDomain::forTargetPlatform(ctx))
+      return targetDomain->getRootDomain().contains(*this);
   }
   return false;
 }
@@ -212,14 +210,31 @@ bool AvailabilityDomain::contains(const AvailabilityDomain &other) const {
   }
 }
 
-AvailabilityDomain AvailabilityDomain::getABICompatibilityDomain() const {
+bool AvailabilityDomain::isRoot() const {
+  switch (getKind()) {
+  case AvailabilityDomain::Kind::Universal:
+  case AvailabilityDomain::Kind::Embedded:
+  case AvailabilityDomain::Kind::SwiftLanguage:
+  case AvailabilityDomain::Kind::PackageDescription:
+    return true;
+  case AvailabilityDomain::Kind::Platform:
+    return getRootDomain() == *this;
+  case AvailabilityDomain::Kind::Custom:
+    // For now, all custom domains are their own root.
+    return true;
+  }
+}
+
+AvailabilityDomain AvailabilityDomain::getRootDomain() const {
   if (!isPlatform())
     return *this;
 
+  // iOS specifically contains a few other platforms.
   auto iOSDomain = AvailabilityDomain::forPlatform(PlatformKind::iOS);
   if (iOSDomain.contains(*this))
     return iOSDomain;
 
+  // App Extension domains are contained by their base platform domain.
   if (auto basePlatform = basePlatformForExtensionPlatform(getPlatformKind()))
     return AvailabilityDomain::forPlatform(*basePlatform);
 

unittests/AST/AvailabilityDomainTests.cpp

@@ -124,19 +124,31 @@ TEST_F(AvailabilityDomainLattice, Contains) {
   EXPECT_FALSE(visionOSAppExt.contains(macOSAppExt));
 }
 
-TEST_F(AvailabilityDomainLattice, ABICompatibilityDomain) {
-  EXPECT_EQ(Universal.getABICompatibilityDomain(), Universal);
-  EXPECT_EQ(Swift.getABICompatibilityDomain(), Swift);
-  EXPECT_EQ(Package.getABICompatibilityDomain(), Package);
-  EXPECT_EQ(Embedded.getABICompatibilityDomain(), Embedded);
-  EXPECT_EQ(macOS.getABICompatibilityDomain(), macOS);
-  EXPECT_EQ(macOSAppExt.getABICompatibilityDomain(), macOS);
-  EXPECT_EQ(iOS.getABICompatibilityDomain(), iOS);
-  EXPECT_EQ(iOSAppExt.getABICompatibilityDomain(), iOS);
-  EXPECT_EQ(macCatalyst.getABICompatibilityDomain(), iOS);
-  EXPECT_EQ(macCatalystAppExt.getABICompatibilityDomain(), iOS);
-  EXPECT_EQ(visionOS.getABICompatibilityDomain(), iOS);
-  EXPECT_EQ(visionOSAppExt.getABICompatibilityDomain(), iOS);
+TEST_F(AvailabilityDomainLattice, RootDomain) {
+  EXPECT_EQ(Universal.getRootDomain(), Universal);
+  EXPECT_TRUE(Universal.isRoot());
+  EXPECT_EQ(Swift.getRootDomain(), Swift);
+  EXPECT_TRUE(Swift.isRoot());
+  EXPECT_EQ(Package.getRootDomain(), Package);
+  EXPECT_TRUE(Package.isRoot());
+  EXPECT_EQ(Embedded.getRootDomain(), Embedded);
+  EXPECT_TRUE(Embedded.isRoot());
+  EXPECT_EQ(macOS.getRootDomain(), macOS);
+  EXPECT_TRUE(macOS.isRoot());
+  EXPECT_EQ(macOSAppExt.getRootDomain(), macOS);
+  EXPECT_FALSE(macOSAppExt.isRoot());
+  EXPECT_EQ(iOS.getRootDomain(), iOS);
+  EXPECT_TRUE(iOS.isRoot());
+  EXPECT_EQ(iOSAppExt.getRootDomain(), iOS);
+  EXPECT_FALSE(iOSAppExt.isRoot());
+  EXPECT_EQ(macCatalyst.getRootDomain(), iOS);
+  EXPECT_FALSE(macCatalyst.isRoot());
+  EXPECT_EQ(macCatalystAppExt.getRootDomain(), iOS);
+  EXPECT_FALSE(macCatalystAppExt.isRoot());
+  EXPECT_EQ(visionOS.getRootDomain(), iOS);
+  EXPECT_FALSE(visionOS.isRoot());
+  EXPECT_EQ(visionOSAppExt.getRootDomain(), iOS);
+  EXPECT_FALSE(visionOSAppExt.isRoot());
 }
 
 TEST(AvailabilityDomain, TargetPlatform) {