AST: Introduce AvailabilityDomain::contains().

This operation describes the partial ordering with which Availability domains
form a lattice.

As a temporary measure, a containment ordering needs to be specified for the
Swift language, Embedded, and Package Description domains. Without this
ordering, there won't be a way for AvailabilityContext to preserve the
invariant that the unavailable domain of a child context contains the
unavailable domain for the parent. However, once AvailabilityContext is
refactored to represent the status of multiple availability domains
simultaneously, the ordering of these domains relative to each other can be
relaxed.

NFC.

Author: tshortli

include/swift/AST/AvailabilityDomain.h

@@ -177,6 +177,11 @@ class AvailabilityDomain final {
   /// Returns the string to use when printing an `@available` attribute.
   llvm::StringRef getNameForAttributePrinting() const;
 
+  /// Returns true if availability in `other` is a subset of availability in
+  /// this domain. The set of all availability domains form a lattice where the
+  /// universal domain (`*`) is the bottom element.
+  bool contains(const AvailabilityDomain &other) const;
+
   bool operator==(const AvailabilityDomain &other) const {
     return storage.getOpaqueValue() == other.storage.getOpaqueValue();
   }
@@ -185,6 +190,7 @@ class AvailabilityDomain final {
     return !(*this == other);
   }
 
+  /// A total, stable ordering on domains.
   bool operator<(const AvailabilityDomain &other) const {
     if (getKind() != other.getKind())
       return getKind() < other.getKind();

lib/AST/AvailabilityDomain.cpp

@@ -57,3 +57,25 @@ llvm::StringRef AvailabilityDomain::getNameForAttributePrinting() const {
     return swift::platformString(getPlatformKind());
   }
 }
+
+bool AvailabilityDomain::contains(const AvailabilityDomain &other) const {
+  // FIXME: [availability] This currently implements something closer to a
+  // total ordering instead of the more flexible partial ordering that it
+  // would ideally represent. Until AvailabilityContext supports tracking
+  // multiple unavailable domains simultaneously, a stricter ordering is
+  // necessary to support source compatibility.
+  switch (getKind()) {
+  case Kind::Universal:
+    return true;
+  case Kind::SwiftLanguage:
+    return !other.isUniversal();
+  case Kind::PackageDescription:
+  case Kind::Embedded:
+    return !other.isUniversal() && !other.isSwiftLanguage();
+  case Kind::Platform:
+    if (getPlatformKind() == other.getPlatformKind())
+      return true;
+    return inheritsAvailabilityFromPlatform(other.getPlatformKind(),
+                                            getPlatformKind());
+  }
+}

unittests/AST/AvailabilityDomainTests.cpp

@@ -0,0 +1,77 @@
+#include "swift/AST/AvailabilityDomain.h"
+#include "gtest/gtest.h"
+
+using namespace swift;
+
+class AvailabilityDomainLattice : public ::testing::Test {
+public:
+  AvailabilityDomain domainForPlatform(PlatformKind kind) {
+    return AvailabilityDomain::forPlatform(kind);
+  }
+  AvailabilityDomain Universal = AvailabilityDomain::forUniversal();
+  AvailabilityDomain Swift = AvailabilityDomain::forSwiftLanguage();
+  AvailabilityDomain Package = AvailabilityDomain::forPackageDescription();
+  AvailabilityDomain Embedded = AvailabilityDomain::forEmbedded();
+  AvailabilityDomain macOS = domainForPlatform(PlatformKind::macOS);
+  AvailabilityDomain macOSAppExt =
+      domainForPlatform(PlatformKind::macOSApplicationExtension);
+  AvailabilityDomain iOS = domainForPlatform(PlatformKind::iOS);
+  AvailabilityDomain iOSAppExt =
+      domainForPlatform(PlatformKind::iOSApplicationExtension);
+  AvailabilityDomain macCatalyst = domainForPlatform(PlatformKind::macCatalyst);
+  AvailabilityDomain macCatalystAppExt =
+      domainForPlatform(PlatformKind::macCatalystApplicationExtension);
+  AvailabilityDomain visionOS = domainForPlatform(PlatformKind::visionOS);
+  AvailabilityDomain visionOSAppExt =
+      domainForPlatform(PlatformKind::visionOSApplicationExtension);
+
+  std::vector<AvailabilityDomain> all() const {
+    return {
+        Universal,   Swift,         Package,   Embedded,    macOS,
+        macOSAppExt, iOS,           iOSAppExt, macCatalyst, macCatalystAppExt,
+        visionOS,    visionOSAppExt};
+  }
+};
+
+TEST_F(AvailabilityDomainLattice, Contains) {
+  for (auto const &domain : all()) {
+    // The universal domain is the bottom domain and contains all others.
+    EXPECT_TRUE(Universal.contains(domain));
+
+    // FIXME: [availability] The following assertions should change when
+    // AvailabilityContext can support multiple simultaneous unavailable
+    // domains.
+
+    // The Swift domain is second from the bottom.
+    EXPECT_EQ(Swift.contains(domain), !domain.isUniversal());
+
+    // Package and Embedded are both third from the bottom.
+    EXPECT_EQ(Package.contains(domain), !domain.isUniversal() && !domain.isSwiftLanguage());
+    EXPECT_EQ(Embedded.contains(domain), !domain.isUniversal() && !domain.isSwiftLanguage());
+  }
+
+  // Platform kind domains form their own lattice in which app extension domains
+  // are contained within the domain of the same platform.
+  EXPECT_TRUE(macOS.contains(macOS));
+  EXPECT_FALSE(macOS.contains(iOS));
+  EXPECT_TRUE(macOS.contains(macOSAppExt));
+  EXPECT_FALSE(macOSAppExt.contains(macOS));
+  EXPECT_FALSE(macOS.contains(macCatalyst));
+  EXPECT_FALSE(macCatalyst.contains(macOS));
+
+  // Additionally, iOS is the ABI platform for both macCatalyst and visionOS and
+  // thus the iOS domain contains those domains.
+  EXPECT_TRUE(iOS.contains(iOS));
+  EXPECT_TRUE(iOS.contains(iOSAppExt));
+  EXPECT_FALSE(iOSAppExt.contains(iOS));
+  EXPECT_TRUE(iOS.contains(macCatalyst));
+  EXPECT_FALSE(macCatalyst.contains(iOS));
+  EXPECT_TRUE(iOS.contains(macCatalystAppExt));
+  EXPECT_FALSE(macCatalystAppExt.contains(iOS));
+  EXPECT_TRUE(iOS.contains(visionOS));
+  EXPECT_FALSE(visionOS.contains(iOS));
+  EXPECT_TRUE(iOS.contains(visionOSAppExt));
+  EXPECT_FALSE(visionOSAppExt.contains(iOS));
+  EXPECT_FALSE(iOS.contains(macOS));
+  EXPECT_FALSE(iOS.contains(macOSAppExt));
+}

unittests/AST/CMakeLists.txt

@@ -2,6 +2,7 @@ add_swift_unittest(SwiftASTTests
   ArithmeticEvaluator.cpp
   ASTDumperTests.cpp
   ASTWalkerTests.cpp
+  AvailabilityDomainTests.cpp
   IndexSubsetTests.cpp
   DiagnosticBehaviorTests.cpp
   DiagnosticConsumerTests.cpp