Merge pull request #78797 from tshortli/availability-context-unavailable-domain

tshortli · web-flow · commit 190779ecd4a1 · 2025-01-22T10:31:51.000-08:00
AST: Track an unavailable domain instead of platform in AvailabilityContext
diff --git a/include/swift/AST/AvailabilityContext.h b/include/swift/AST/AvailabilityContext.h
@@ -18,6 +18,7 @@
 #ifndef SWIFT_AST_AVAILABILITY_CONTEXT_H
 #define SWIFT_AST_AVAILABILITY_CONTEXT_H
 
+#include "swift/AST/AvailabilityDomain.h"
 #include "swift/AST/AvailabilityRange.h"
 #include "swift/AST/PlatformKind.h"
 #include "swift/Basic/Debug.h"
@@ -51,7 +52,7 @@ class AvailabilityContext {
   /// parameters.
   static AvailabilityContext
   get(const AvailabilityRange &platformAvailability,
-      std::optional<PlatformKind> unavailablePlatform, bool deprecated,
+      std::optional<AvailabilityDomain> unavailableDomain, bool deprecated,
       ASTContext &ctx);
 
 public:
@@ -73,22 +74,16 @@ class AvailabilityContext {
   /// availability context, starting at its introduction version.
   AvailabilityRange getPlatformRange() const;
 
-  /// When the context is unavailable on the current platform this returns the
-  /// broadest `PlatformKind` for which the context is unavailable. Otherwise,
-  /// returns `nullopt`.
-  std::optional<PlatformKind> getUnavailablePlatformKind() const;
+  /// Returns the broadest AvailabilityDomain that is unavailable in this
+  /// context.
+  std::optional<AvailabilityDomain> getUnavailableDomain() const;
 
   /// Returns true if this context is unavailable.
-  bool isUnavailable() const {
-    return getUnavailablePlatformKind().has_value();
-  }
+  bool isUnavailable() const { return getUnavailableDomain().has_value(); }
 
   /// Returns true if this context is deprecated on the current platform.
   bool isDeprecated() const;
 
-  /// Returns true if this context is `@_unavailableInEmbedded`.
-  bool isUnavailableInEmbedded() const;
-
   /// Constrain with another `AvailabilityContext`.
   void constrainWithContext(const AvailabilityContext &other, ASTContext &ctx);
 
diff --git a/include/swift/AST/AvailabilityContextStorage.h b/include/swift/AST/AvailabilityContextStorage.h
@@ -29,16 +29,8 @@ class AvailabilityContext::Info {
   /// The introduction version.
   AvailabilityRange Range;
 
-  /// When `IsUnavailable` is true, this value stores the broadest platform
-  /// kind for which the context is unavailable.
-  PlatformKind UnavailablePlatform;
-
-  /// Whether or not the context is considered unavailable on the current
-  /// platform.
-  unsigned IsUnavailable : 1;
-
-  /// Whether or not the context is `@_unavailableInEmbedded`.
-  unsigned IsUnavailableInEmbedded : 1;
+  /// The broadest unavailable domain.
+  std::optional<AvailabilityDomain> UnavailableDomain;
 
   /// Whether or not the context is considered deprecated on the current
   /// platform.
@@ -53,16 +45,18 @@ class AvailabilityContext::Info {
   /// availability is more restrictive. Returns true if any field was updated.
   bool constrainWith(const Decl *decl);
 
-  bool constrainUnavailability(std::optional<PlatformKind> unavailablePlatform);
+  bool constrainUnavailability(std::optional<AvailabilityDomain> domain);
 
   /// Returns true if `other` is as available or is more available.
   bool isContainedIn(const Info &other) const;
 
   void Profile(llvm::FoldingSetNodeID &ID) const {
     Range.getRawVersionRange().Profile(ID);
-    ID.AddBoolean(IsUnavailable);
-    ID.AddBoolean(IsUnavailableInEmbedded);
-    ID.AddInteger(static_cast<uint8_t>(UnavailablePlatform));
+    if (UnavailableDomain) {
+      UnavailableDomain->Profile(ID);
+    } else {
+      ID.AddPointer(nullptr);
+    }
     ID.AddBoolean(IsDeprecated);
   }
 };
@@ -77,7 +71,7 @@ class AvailabilityContext::Storage final : public llvm::FoldingSetNode {
 
   static const Storage *get(const Info &info, ASTContext &ctx);
 
-  void Profile(llvm::FoldingSetNodeID &ID) const;
+  void Profile(llvm::FoldingSetNodeID &ID) const { info.Profile(ID); }
 };
 
 } // end namespace swift
diff --git a/include/swift/AST/AvailabilityDomain.h b/include/swift/AST/AvailabilityDomain.h
@@ -20,6 +20,7 @@
 
 #include "swift/AST/PlatformKind.h"
 #include "swift/Basic/LLVM.h"
+#include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 #include "llvm/ADT/PointerUnion.h"
 
@@ -177,6 +178,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 +191,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();
@@ -200,6 +207,10 @@ class AvailabilityDomain final {
       return getPlatformKind() < other.getPlatformKind();
     }
   }
+
+  void Profile(llvm::FoldingSetNodeID &ID) const {
+    ID.AddPointer(getOpaqueValue());
+  }
 };
 
 } // end namespace swift
diff --git a/lib/AST/AvailabilityContext.cpp b/lib/AST/AvailabilityContext.cpp
@@ -37,14 +37,27 @@ static bool constrainRange(AvailabilityRange &existing,
   return true;
 }
 
+static bool constrainUnavailableDomain(
+    std::optional<AvailabilityDomain> &domain,
+    const std::optional<AvailabilityDomain> &otherDomain) {
+  // If the other domain is absent or is the same domain, it's a noop.
+  if (!otherDomain || domain == otherDomain)
+    return false;
+
+  // Check if the other domain is a superset and constrain to it if it is.
+  if (!domain || otherDomain->contains(*domain)) {
+    domain = otherDomain;
+    return true;
+  }
+
+  return false;
+}
+
 bool AvailabilityContext::Info::constrainWith(const Info &other) {
   bool isConstrained = false;
   isConstrained |= constrainRange(Range, other.Range);
-  if (other.IsUnavailable) {
-    isConstrained |= constrainUnavailability(other.UnavailablePlatform);
-    isConstrained |=
-        CONSTRAIN_BOOL(IsUnavailableInEmbedded, other.IsUnavailableInEmbedded);
-  }
+  if (other.UnavailableDomain)
+    isConstrained |= constrainUnavailability(other.UnavailableDomain);
   isConstrained |= CONSTRAIN_BOOL(IsDeprecated, other.IsDeprecated);
 
   return isConstrained;
@@ -56,77 +69,44 @@ bool AvailabilityContext::Info::constrainWith(const Decl *decl) {
   if (auto range = AvailabilityInference::annotatedAvailableRange(decl))
     isConstrained |= constrainRange(Range, *range);
 
-  if (auto attr = decl->getUnavailableAttr()) {
-    isConstrained |= constrainUnavailability(attr->getPlatform());
-    isConstrained |=
-        CONSTRAIN_BOOL(IsUnavailableInEmbedded, attr->isEmbeddedSpecific());
-  }
+  if (auto attr = decl->getUnavailableAttr())
+    isConstrained |= constrainUnavailability(attr->getDomain());
 
   isConstrained |= CONSTRAIN_BOOL(IsDeprecated, decl->isDeprecated());
 
   return isConstrained;
 }
 
 bool AvailabilityContext::Info::constrainUnavailability(
-    std::optional<PlatformKind> unavailablePlatform) {
-  if (!unavailablePlatform)
-    return false;
-
-  if (IsUnavailable) {
-    // Universal unavailability cannot be refined.
-    if (UnavailablePlatform == PlatformKind::none)
-      return false;
-
-    // There's nothing to do if the platforms already match.
-    if (UnavailablePlatform == *unavailablePlatform)
-      return false;
-
-    // The new platform must be more restrictive.
-    if (*unavailablePlatform != PlatformKind::none &&
-        inheritsAvailabilityFromPlatform(*unavailablePlatform,
-                                         UnavailablePlatform))
-      return false;
-  }
-
-  IsUnavailable = true;
-  UnavailablePlatform = *unavailablePlatform;
-  return true;
+    std::optional<AvailabilityDomain> domain) {
+  return constrainUnavailableDomain(UnavailableDomain, domain);
 }
 
 bool AvailabilityContext::Info::isContainedIn(const Info &other) const {
+  // The available versions range be the same or smaller.
   if (!Range.isContainedIn(other.Range))
     return false;
 
-  if (!IsUnavailable && other.IsUnavailable)
-    return false;
-
-  if (IsUnavailable && other.IsUnavailable) {
-    if (UnavailablePlatform != other.UnavailablePlatform &&
-        UnavailablePlatform != PlatformKind::none &&
-        inheritsAvailabilityFromPlatform(UnavailablePlatform,
-                                         other.UnavailablePlatform))
+  // The set of unavailable domains should be the same or larger.
+  if (auto otherUnavailableDomain = other.UnavailableDomain) {
+    if (!UnavailableDomain)
       return false;
 
-    if (IsUnavailableInEmbedded && !other.IsUnavailableInEmbedded)
+    if (!UnavailableDomain->contains(otherUnavailableDomain.value()))
       return false;
   }
 
+  // The set of deprecated domains should be the same or larger.
   if (!IsDeprecated && other.IsDeprecated)
     return false;
 
   return true;
 }
 
-void AvailabilityContext::Storage::Profile(llvm::FoldingSetNodeID &id) const {
-  info.Profile(id);
-}
-
 AvailabilityContext
 AvailabilityContext::forPlatformRange(const AvailabilityRange &range,
                                       ASTContext &ctx) {
-  Info info{range, PlatformKind::none,
-            /*IsUnavailable*/ false,
-            /*IsUnavailableInEmbedded*/ false,
+  Info info{range, /*UnavailableDomain*/ std::nullopt,
             /*IsDeprecated*/ false};
   return AvailabilityContext(Storage::get(info, ctx));
 }
@@ -143,29 +123,19 @@ AvailabilityContext AvailabilityContext::forDeploymentTarget(ASTContext &ctx) {
 
 AvailabilityContext
 AvailabilityContext::get(const AvailabilityRange &platformAvailability,
-                         std::optional<PlatformKind> unavailablePlatform,
+                         std::optional<AvailabilityDomain> unavailableDomain,
                          bool deprecated, ASTContext &ctx) {
-  Info info{platformAvailability,
-            unavailablePlatform.has_value() ? *unavailablePlatform
-                                            : PlatformKind::none,
-            unavailablePlatform.has_value(),
-            /*IsUnavailableInEmbedded*/ false, deprecated};
+  Info info{platformAvailability, unavailableDomain, deprecated};
   return AvailabilityContext(Storage::get(info, ctx));
 }
 
 AvailabilityRange AvailabilityContext::getPlatformRange() const {
   return storage->info.Range;
 }
 
-std::optional<PlatformKind>
-AvailabilityContext::getUnavailablePlatformKind() const {
-  if (storage->info.IsUnavailable)
-    return storage->info.UnavailablePlatform;
-  return std::nullopt;
-}
-
-bool AvailabilityContext::isUnavailableInEmbedded() const {
-  return storage->info.IsUnavailableInEmbedded;
+std::optional<AvailabilityDomain>
+AvailabilityContext::getUnavailableDomain() const {
+  return storage->info.UnavailableDomain;
 }
 
 bool AvailabilityContext::isDeprecated() const {
@@ -233,8 +203,8 @@ stringForAvailability(const AvailabilityRange &availability) {
 void AvailabilityContext::print(llvm::raw_ostream &os) const {
   os << "version=" << stringForAvailability(getPlatformRange());
 
-  if (auto unavailablePlatform = getUnavailablePlatformKind())
-    os << " unavailable=" << platformString(*unavailablePlatform);
+  if (auto unavailableDomain = getUnavailableDomain())
+    os << " unavailable=" << unavailableDomain->getNameForAttributePrinting();
 
   if (isDeprecated())
     os << " deprecated";
diff --git a/lib/AST/AvailabilityDomain.cpp b/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());
+  }
+}
diff --git a/lib/Sema/TypeCheckAccess.cpp b/lib/Sema/TypeCheckAccess.cpp
@@ -2019,7 +2019,7 @@ swift::getDisallowedOriginKind(const Decl *decl,
       // Decls with @_spi_available aren't hidden entirely from public interfaces,
       // thus public interfaces may still refer them. Be forgiving here so public
       // interfaces can compile.
-      if (where.getUnavailablePlatformKind().has_value())
+      if (where.getAvailability().isUnavailable())
         return DisallowedOriginKind::None;
       // We should only diagnose SPI_AVAILABLE usage when the library level is API.
       // Using SPI_AVAILABLE symbols in private frameworks or executable targets
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -5050,13 +5050,13 @@ void AttributeChecker::checkBackDeployedAttrs(
     if (Ctx.LangOpts.DisableAvailabilityChecking)
       continue;
 
-    auto availability =
-        TypeChecker::availabilityAtLocation(D->getLoc(), D->getDeclContext());
+    auto availability = TypeChecker::availabilityAtLocation(
+        D->getLoc(), D->getInnermostDeclContext());
 
     // Unavailable decls cannot be back deployed.
-    if (auto unavailablePlatform = availability.getUnavailablePlatformKind()) {
-      if (!inheritsAvailabilityFromPlatform(*unavailablePlatform,
-                                            Attr->Platform)) {
+    if (auto unavailableDomain = availability.getUnavailableDomain()) {
+      auto backDeployedDomain = AvailabilityDomain::forPlatform(Attr->Platform);
+      if (unavailableDomain->contains(backDeployedDomain)) {
         auto platformString = prettyPlatformString(Attr->Platform);
         llvm::VersionTuple ignoredVersion;
 
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
@@ -349,28 +349,22 @@ static bool computeContainedByDeploymentTarget(AvailabilityScope *scope,
 static bool isInsideCompatibleUnavailableDeclaration(
     const Decl *D, AvailabilityContext availabilityContext,
     const SemanticAvailableAttr &attr) {
-  auto contextPlatform = availabilityContext.getUnavailablePlatformKind();
-  if (!contextPlatform)
+  auto contextDomain = availabilityContext.getUnavailableDomain();
+  if (!contextDomain)
     return false;
 
   if (!attr.isUnconditionallyUnavailable())
     return false;
 
   // Refuse calling universally unavailable functions from unavailable code,
   // but allow the use of types.
-  PlatformKind declPlatform = attr.getPlatform();
-  if (declPlatform == PlatformKind::none && !attr.isEmbeddedSpecific() &&
-      !isa<TypeDecl>(D) && !isa<ExtensionDecl>(D))
-    return false;
-
-  // @_unavailableInEmbedded declarations may be used in contexts that are
-  // also @_unavailableInEmbedded.
-  if (attr.isEmbeddedSpecific())
-    return availabilityContext.isUnavailableInEmbedded();
+  auto declDomain = attr.getDomain();
+  if (!isa<TypeDecl>(D) && !isa<ExtensionDecl>(D)) {
+    if (declDomain.isUniversal() || declDomain.isSwiftLanguage())
+      return false;
+  }
 
-  return (*contextPlatform == PlatformKind::none ||
-          *contextPlatform == declPlatform ||
-          inheritsAvailabilityFromPlatform(declPlatform, *contextPlatform));
+  return contextDomain->contains(declDomain);
 }
 
 std::optional<SemanticAvailableAttr>
diff --git a/lib/Sema/TypeCheckAvailability.h b/lib/Sema/TypeCheckAvailability.h
diff --git a/test/embedded/availability.swift b/test/embedded/availability.swift
diff --git a/unittests/AST/AvailabilityDomainTests.cpp b/unittests/AST/AvailabilityDomainTests.cpp
diff --git a/unittests/AST/CMakeLists.txt b/unittests/AST/CMakeLists.txt
