Merge pull request swiftlang#77159 from tshortli/adopt-availability-context-in-export-context

Sema: Adopt AvailabilityContext in ExportContext

Author: tshortli

include/swift/AST/AvailabilityContext.h

@@ -71,14 +71,20 @@ class AvailabilityContext {
   /// Returns true if this context is deprecated on the current platform.
   bool isDeprecated() const;
 
+  /// Constrain with another `AvailabilityContext`.
+  void constrainWithContext(const AvailabilityContext &other, ASTContext &ctx);
+
+  /// Constrain with the availability attributes of `decl`.
+  void constrainWithDecl(const Decl *decl);
+
   /// Constrain the platform availability range with `platformRange`.
   void constrainWithPlatformRange(const AvailabilityRange &platformRange,
                                   ASTContext &ctx);
 
-  /// Constrain the platform availability range with both the availability
-  /// attributes of `decl` and with `platformRange`.
+  /// Constrain with the availability attributes of `decl`, intersecting the
+  /// platform range of `decl` with `platformRange`.
   void
-  constrainWithDeclAndPlatformRange(Decl *decl,
+  constrainWithDeclAndPlatformRange(const Decl *decl,
                                     const AvailabilityRange &platformRange);
 
   /// Returns true if `other` is as available or is more available.

include/swift/AST/AvailabilityContextStorage.h

@@ -40,8 +40,15 @@ struct AvailabilityContext::PlatformInfo {
   /// platform.
   unsigned IsDeprecated : 1;
 
-  /// Sets `Range` to `other` if `other` is more restrictive. Returns true if
-  /// any property changed as a result of adding this constraint.
+  /// Sets each field to the value of the corresponding field in `other` if the
+  /// other is more restrictive. Returns true if any field changed as a result
+  /// of adding this constraint.
+  bool constrainWith(const PlatformInfo &other);
+
+  /// Updates each field to reflect the availability of `decl`, if that
+  /// availability is more restrictive. Returns true if any field was updated.
+  bool constrainWith(const Decl *decl);
+
   bool constrainRange(const AvailabilityRange &other) {
     if (!other.isContainedIn(Range))
       return false;
@@ -50,19 +57,9 @@ struct AvailabilityContext::PlatformInfo {
     return true;
   }
 
-  /// Sets `Range` to the platform introduction range of `decl` if that range
-  /// is more restrictive. Returns true if
-  /// any property changed as a result of adding this constraint.
-  bool constrainRange(const Decl *decl);
-
-  /// Updates `UnavailablePlatform` and `IsUnavailable` to reflect the status
-  /// of `decl` if its platform unavailability is more restrictive. Returns
-  /// true if any property changed as a result of adding this constraint.
-  bool constrainUnavailability(const Decl *decl);
+  bool constrainUnavailability(std::optional<PlatformKind> unavailablePlatform);
 
-  /// If `decl` is deprecated, sets `IsDeprecated` to true. Returns true if
-  /// any property changed as a result of adding this constraint.
-  bool constrainDeprecated(const Decl *decl);
+  bool constrainDeprecated(bool deprecated);
 
   /// Returns true if `other` is as available or is more available.
   bool isContainedIn(const PlatformInfo &other) const;

lib/AST/AvailabilityContext.cpp

@@ -18,37 +18,62 @@
 
 using namespace swift;
 
-bool AvailabilityContext::PlatformInfo::constrainRange(const Decl *decl) {
+bool AvailabilityContext::PlatformInfo::constrainWith(
+    const PlatformInfo &other) {
+  bool isConstrained = false;
+  isConstrained |= constrainRange(other.Range);
+  if (other.IsUnavailable) {
+    isConstrained |= constrainUnavailability(other.UnavailablePlatform);
+  }
+  isConstrained |= constrainDeprecated(other.IsDeprecated);
+
+  return isConstrained;
+}
+
+bool AvailabilityContext::PlatformInfo::constrainWith(const Decl *decl) {
+  bool isConstrained = false;
+  auto &ctx = decl->getASTContext();
+
   if (auto range = AvailabilityInference::annotatedAvailableRange(decl))
-    return constrainRange(*range);
+    isConstrained |= constrainRange(*range);
+
+  if (auto *attr = decl->getAttrs().getUnavailable(ctx))
+    isConstrained |= constrainUnavailability(attr->Platform);
+
+  if (!IsDeprecated)
+    isConstrained |= constrainDeprecated(decl->getAttrs().isDeprecated(ctx));
 
-  return false;
+  return isConstrained;
 }
 
 bool AvailabilityContext::PlatformInfo::constrainUnavailability(
-    const Decl *decl) {
-  auto &ctx = decl->getASTContext();
-  auto *attr = decl->getAttrs().getUnavailable(ctx);
-  if (!attr)
+    std::optional<PlatformKind> unavailablePlatform) {
+  if (!unavailablePlatform)
     return false;
 
-  // Check whether the decl's unavailability reason is the same.
-  if (IsUnavailable && UnavailablePlatform == attr->Platform)
-    return false;
+  if (IsUnavailable) {
+    // Universal unavailability cannot be refined.
+    if (UnavailablePlatform == PlatformKind::none)
+      return false;
 
-  // Check whether the decl's unavailability reason is more specific.
-  if (attr->Platform != PlatformKind::none &&
-      inheritsAvailabilityFromPlatform(attr->Platform, UnavailablePlatform))
-    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 = attr->Platform;
+  UnavailablePlatform = *unavailablePlatform;
   return true;
 }
 
-bool AvailabilityContext::PlatformInfo::constrainDeprecated(const Decl *decl) {
-  auto &ctx = decl->getASTContext();
-  if (IsDeprecated || !decl->getAttrs().isDeprecated(ctx))
+bool AvailabilityContext::PlatformInfo::constrainDeprecated(bool deprecated) {
+  if (IsDeprecated || !deprecated)
     return false;
 
   IsDeprecated = true;
@@ -116,6 +141,18 @@ bool AvailabilityContext::isDeprecated() const {
   return Info->Platform.IsDeprecated;
 }
 
+void AvailabilityContext::constrainWithContext(const AvailabilityContext &other,
+                                               ASTContext &ctx) {
+  PlatformInfo platformAvailability{Info->Platform};
+  if (platformAvailability.constrainWith(other.Info->Platform)) {
+    Info = Storage::get(platformAvailability, ctx);
+  }
+}
+
+void AvailabilityContext::constrainWithDecl(const Decl *decl) {
+  constrainWithDeclAndPlatformRange(decl, AvailabilityRange::alwaysAvailable());
+}
+
 void AvailabilityContext::constrainWithPlatformRange(
     const AvailabilityRange &platformRange, ASTContext &ctx) {
   PlatformInfo platformAvailability{Info->Platform};
@@ -126,13 +163,11 @@ void AvailabilityContext::constrainWithPlatformRange(
 }
 
 void AvailabilityContext::constrainWithDeclAndPlatformRange(
-    Decl *decl, const AvailabilityRange &platformRange) {
+    const Decl *decl, const AvailabilityRange &platformRange) {
   PlatformInfo platformAvailability{Info->Platform};
   bool isConstrained = false;
-  isConstrained |= platformAvailability.constrainRange(decl);
+  isConstrained |= platformAvailability.constrainWith(decl);
   isConstrained |= platformAvailability.constrainRange(platformRange);
-  isConstrained |= platformAvailability.constrainUnavailability(decl);
-  isConstrained |= platformAvailability.constrainDeprecated(decl);
 
   if (!isConstrained)
     return;