AST: Introduce some AvailabilityDomain conveniences.

One to get the active domain for the compilation target and another to get the
ABI compatibility domain for a given domain. The ABI compatibility domain will
be needed for queries that compute whether an unavailable declaration is still
reachable at runtime.

NFC.

Author: tshortli

include/swift/AST/AvailabilityDomain.h

@@ -21,6 +21,7 @@
 #include "swift/AST/ASTAllocated.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/PlatformKind.h"
+#include "swift/Basic/Assertions.h"
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
@@ -102,7 +103,7 @@ class AvailabilityDomain final {
 
   AvailabilityDomain(Kind kind)
       : storage(InlineDomain(kind, PlatformKind::none).asInteger()) {
-    assert(kind != Kind::Platform);
+    DEBUG_ASSERT(kind != Kind::Platform);
   };
 
   AvailabilityDomain(PlatformKind platform)
@@ -120,7 +121,7 @@ class AvailabilityDomain final {
   }
 
   CustomAvailabilityDomain *getCustomDomain() const {
-    assert(isCustom());
+    ASSERT(isCustom());
     return storage.get<CustomAvailabilityDomain *>();
   }
 
@@ -132,6 +133,8 @@ class AvailabilityDomain final {
   }
 
   static AvailabilityDomain forPlatform(PlatformKind platformKind) {
+    bool isPlatform = platformKind != PlatformKind::none;
+    ASSERT(isPlatform);
     return AvailabilityDomain(platformKind);
   }
 
@@ -151,6 +154,11 @@ class AvailabilityDomain final {
     return AvailabilityDomain(domain);
   }
 
+  /// Returns the most specific platform domain that applies to the compilation
+  /// context.
+  static std::optional<AvailabilityDomain>
+  forTargetPlatform(const ASTContext &ctx);
+
   /// Returns the built-in availability domain identified by the given string.
   static std::optional<AvailabilityDomain>
   builtinDomainForString(StringRef string, const DeclContext *declContext);
@@ -213,6 +221,11 @@ 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;
+
   bool operator==(const AvailabilityDomain &other) const {
     return storage.getOpaqueValue() == other.storage.getOpaqueValue();
   }

lib/AST/AvailabilityDomain.cpp

@@ -18,6 +18,15 @@
 
 using namespace swift;
 
+std::optional<AvailabilityDomain>
+AvailabilityDomain::forTargetPlatform(const ASTContext &ctx) {
+  auto platform = swift::targetPlatform(ctx.LangOpts);
+  if (platform == PlatformKind::none)
+    return std::nullopt;
+
+  return forPlatform(platform);
+}
+
 std::optional<AvailabilityDomain>
 AvailabilityDomain::builtinDomainForString(StringRef string,
                                            const DeclContext *declContext) {
@@ -136,6 +145,20 @@ bool AvailabilityDomain::contains(const AvailabilityDomain &other) const {
   }
 }
 
+AvailabilityDomain AvailabilityDomain::getABICompatibilityDomain() const {
+  if (!isPlatform())
+    return *this;
+
+  auto iOSDomain = AvailabilityDomain::forPlatform(PlatformKind::iOS);
+  if (iOSDomain.contains(*this))
+    return iOSDomain;
+
+  if (auto basePlatform = basePlatformForExtensionPlatform(getPlatformKind()))
+    return AvailabilityDomain::forPlatform(*basePlatform);
+
+  return *this;
+}
+
 CustomAvailabilityDomain::CustomAvailabilityDomain(Identifier name,
                                                    ModuleDecl *mod, Kind kind)
     : name(name), kind(kind), mod(mod) {

unittests/AST/AvailabilityContextTests.cpp

@@ -30,7 +30,7 @@ static AvailabilityRange getAvailabilityRange(unsigned major, unsigned minor) {
 class AvailabilityContextTest : public ::testing::Test {
 public:
   const TestContext defaultTestContext{
-      DoNotDeclareOptionalTypes, llvm::Triple("x86_64", "apple", "macosx10.9")};
+      llvm::Triple("x86_64", "apple", "macosx10.9")};
 
   struct {
     const AvailabilityDomain universal = AvailabilityDomain::forUniversal();

unittests/AST/AvailabilityDomainTests.cpp

@@ -10,10 +10,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "TestContext.h"
 #include "swift/AST/AvailabilityDomain.h"
 #include "gtest/gtest.h"
 
 using namespace swift;
+using namespace swift::unittest;
 
 class AvailabilityDomainLattice : public ::testing::Test {
 public:
@@ -127,3 +129,47 @@ TEST_F(AvailabilityDomainLattice, Contains) {
   EXPECT_FALSE(visionOSAppExt.contains(macOS));
   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(AvailabilityDomain, TargetPlatform) {
+  using namespace llvm;
+
+  struct TargetToPlatformKind {
+    Triple target;
+    PlatformKind platformKind;
+  };
+  TargetToPlatformKind tests[] = {
+      {Triple("x86_64", "apple", "macosx10.15"), PlatformKind::macOS},
+      {Triple("arm64", "apple", "ios13"), PlatformKind::iOS},
+      {Triple("arm64_32", "apple", "watchos8"), PlatformKind::watchOS},
+      {Triple("x86_64", "apple", "ios14", "macabi"), PlatformKind::macCatalyst},
+      {Triple("x86_64", "unknown", "windows", "msvc"), PlatformKind::none},
+      {Triple("x86_64", "unknown", "linux", "gnu"), PlatformKind::none},
+  };
+
+  for (TargetToPlatformKind test : tests) {
+    TestContext context{test.target};
+    auto domain = AvailabilityDomain::forTargetPlatform(context.Ctx);
+    if (test.platformKind != PlatformKind::none) {
+      EXPECT_TRUE(domain);
+      if (domain)
+        EXPECT_TRUE(domain->getPlatformKind() == test.platformKind);
+    } else {
+      EXPECT_FALSE(domain);
+    }
+  }
+}

unittests/AST/TestContext.h

@@ -61,6 +61,9 @@ class TestContext : public TestContextBase {
       ShouldDeclareOptionalTypes optionals = DoNotDeclareOptionalTypes,
       llvm::Triple target = llvm::Triple(llvm::sys::getProcessTriple()));
 
+  TestContext(llvm::Triple target)
+      : TestContext(DoNotDeclareOptionalTypes, target) {};
+
   template <typename Nominal>
   typename std::enable_if<!std::is_same<Nominal, swift::ClassDecl>::value,
                           Nominal *>::type