AST: Track an unavailable domain instead of platform in AvailabilityContext.

Now that most of the compiler tracks availability in terms of
AvailabilityDomain, it's time to do so in AvailabilityContext as well. This
will ensure that the compiler accurately suppresses diagnostics about a decl
being unavailable in an arbitrary domain when the context of the use is already
unavailable in that domain.

With this change, most of the special-casing for the Embedded Swift availability
domain has been removed from the compiler, outside of parsing and interface
printing.

Author: tshortli

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);
 

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

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"
 
@@ -206,6 +207,10 @@ class AvailabilityDomain final {
       return getPlatformKind() < other.getPlatformKind();
     }
   }
+
+  void Profile(llvm::FoldingSetNodeID &ID) const {
+    ID.AddPointer(getOpaqueValue());
+  }
 };
 
 } // end namespace swift

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";

lib/Sema/TypeCheckAccess.cpp

@@ -2017,7 +2017,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

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;
 

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>

lib/Sema/TypeCheckAvailability.h

@@ -193,10 +193,6 @@ class ExportContext {
   /// reference other deprecated declarations without warning.
   bool isDeprecated() const { return Availability.isDeprecated(); }
 
-  std::optional<PlatformKind> getUnavailablePlatformKind() const {
-    return Availability.getUnavailablePlatformKind();
-  }
-
   /// If true, the context can only reference exported declarations, either
   /// because it is the signature context of an exported declaration, or
   /// because it is the function body context of an inlinable function.

test/embedded/availability.swift

@@ -13,7 +13,7 @@ public struct UniverallyUnavailable {}
 
 @_unavailableInEmbedded
 public func unavailable_in_embedded() { }
-// expected-note@-1 2 {{'unavailable_in_embedded()' has been explicitly marked unavailable here}}
+// expected-note@-1 {{'unavailable_in_embedded()' has been explicitly marked unavailable here}}
 
 @available(*, unavailable, message: "always unavailable")
 public func universally_unavailable() { }
@@ -22,8 +22,8 @@ public func universally_unavailable() { }
 @_unavailableInEmbedded
 public func unused() { } // no error
 
-public struct S1 {} // expected-note {{found this candidate}}
-public struct S2 {} // expected-note {{found this candidate}}
+public struct S1 {} // expected-note 2 {{found this candidate}}
+public struct S2 {} // expected-note 2 {{found this candidate}}
 
 @_unavailableInEmbedded
 public func has_unavailable_in_embedded_overload(_ s1: S1) { }
@@ -61,8 +61,8 @@ public func also_universally_unavailable(
   _ uie: UnavailableInEmbedded, // OK
   _ uu: UniverallyUnavailable // OK
 ) {
-  unavailable_in_embedded() // expected-error {{'unavailable_in_embedded()' is unavailable: unavailable in embedded Swift}}
+  unavailable_in_embedded()
   universally_unavailable() // expected-error {{'universally_unavailable()' is unavailable: always unavailable}}
-  has_unavailable_in_embedded_overload(.init()) // not ambiguous, selects available overload
+  has_unavailable_in_embedded_overload(.init()) // expected-error {{ambiguous use of 'init()'}}
   has_universally_unavailable_overload(.init()) // not ambiguous, selects available overload
 }