Merge pull request #76203 from tshortli/availability-context-cleanup

AST: Clean up `AvailabilityContext` and uses

Author: tshortli

include/swift/AST/ASTContext.h

@@ -1578,6 +1578,10 @@ class ASTContext final {
 
 public:
   clang::DarwinSDKInfo *getDarwinSDKInfo() const;
+
+  /// Returns the string to use in diagnostics when printing the platform being
+  /// targetted.
+  StringRef getTargetPlatformStringForDiagnostics() const;
 };
 
 } // end namespace swift

include/swift/AST/Availability.h

@@ -194,30 +194,7 @@ class VersionRange {
   }
 };
 
-/// Records the reason a declaration is potentially unavailable.
-class UnavailabilityReason {
-private:
-  VersionRange RequiredDeploymentRange;
-
-  explicit UnavailabilityReason(const VersionRange RequiredDeploymentRange)
-      : RequiredDeploymentRange(RequiredDeploymentRange) {}
-
-public:
-  static UnavailabilityReason requiresVersionRange(const VersionRange Range) {
-    return UnavailabilityReason(Range);
-  }
-
-  const VersionRange &getRequiredOSVersionRange() const {
-    return RequiredDeploymentRange;
-  }
-
-  /// Returns true if the required OS version range's lower endpoint is at or
-  /// below the deployment target of the given ASTContext.
-  bool requiresDeploymentTargetOrEarlier(ASTContext &Ctx) const;
-};
-
-/// Represents everything that a particular chunk of code may assume about its
-/// runtime environment.
+/// Represents a version range in which something is available.
 ///
 /// The AvailabilityContext structure forms a [lattice][], which allows it to
 /// have meaningful union and intersection operations ("join" and "meet"),
@@ -229,14 +206,10 @@ class UnavailabilityReason {
 /// NOTE: Generally you should use the utilities on \c AvailabilityInference
 /// to create an \c AvailabilityContext, rather than creating one directly.
 class AvailabilityContext {
-  VersionRange OSVersion;
-  std::optional<bool> SPI;
+  VersionRange Range;
 
 public:
-  /// Creates a context that requires certain versions of the target OS.
-  explicit AvailabilityContext(VersionRange OSVersion,
-                               std::optional<bool> SPI = std::nullopt)
-      : OSVersion(OSVersion), SPI(SPI) {}
+  explicit AvailabilityContext(VersionRange Range) : Range(Range) {}
 
   /// Creates a context that imposes the constraints of the ASTContext's
   /// deployment target.
@@ -264,21 +237,34 @@ class AvailabilityContext {
     return AvailabilityContext(VersionRange::empty());
   }
 
-  /// Returns the range of possible OS versions required by this context.
-  VersionRange getOSVersion() const { return OSVersion; }
+  /// Returns the range of possible versions required by this context.
+  VersionRange getRawVersionRange() const { return Range; }
+
+  /// Returns true if there is a version tuple for this context.
+  bool hasMinimumVersion() const { return Range.hasLowerEndpoint(); }
+
+  /// Returns the minimum version required by this context. This convenience
+  /// is meant for debugging, diagnostics, serialization, etc. Use of the set
+  /// algebra operations on `AvailabilityContext` should be preferred over
+  /// direct comparison of raw versions.
+  ///
+  /// Only call when `hasMinimumVersion()` returns true.
+  llvm::VersionTuple getRawMinimumVersion() const {
+    return Range.getLowerEndpoint();
+  }
 
   /// Returns true if \p other makes stronger guarantees than this context.
   ///
   /// That is, `a.isContainedIn(b)` implies `a.union(b) == b`.
   bool isContainedIn(const AvailabilityContext &other) const {
-    return OSVersion.isContainedIn(other.OSVersion);
+    return Range.isContainedIn(other.Range);
   }
 
   /// Returns true if \p other is a strict subset of this context.
   ///
   /// That is, `a.isSupersetOf(b)` implies `a != b` and `a.union(b) == a`.
   bool isSupersetOf(const AvailabilityContext &other) const {
-    return OSVersion.isSupersetOf(other.OSVersion);
+    return Range.isSupersetOf(other.Range);
   }
 
   /// Returns true if this context has constraints that make it impossible to
@@ -287,13 +273,13 @@ class AvailabilityContext {
   /// For example, the else branch of a `#available` check for iOS 8.0 when the
   /// containing function already requires iOS 9.
   bool isKnownUnreachable() const {
-    return OSVersion.isEmpty();
+    return Range.isEmpty();
   }
 
   /// Returns true if there are no constraints on this context; that is,
   /// nothing can be assumed.
   bool isAlwaysAvailable() const {
-    return OSVersion.isAll();
+    return Range.isAll();
   }
 
   /// Produces an under-approximation of the intersection of the two
@@ -306,7 +292,7 @@ class AvailabilityContext {
   /// As an example, this is used when figuring out the required availability
   /// for a type that references multiple nominal decls.
   void intersectWith(const AvailabilityContext &other) {
-    OSVersion.intersectWith(other.getOSVersion());
+    Range.intersectWith(other.Range);
   }
 
   /// Produces an over-approximation of the intersection of the two
@@ -317,7 +303,7 @@ class AvailabilityContext {
   ///
   /// As an example, this is used for the true branch of `#available`.
   void constrainWith(const AvailabilityContext &other) {
-    OSVersion.constrainWith(other.getOSVersion());
+    Range.constrainWith(other.Range);
   }
 
   /// Produces an over-approximation of the union of two availability contexts.
@@ -329,15 +315,19 @@ class AvailabilityContext {
   /// As an example, this is used for the else branch of a conditional with
   /// multiple `#available` checks.
   void unionWith(const AvailabilityContext &other) {
-    OSVersion.unionWith(other.getOSVersion());
+    Range.unionWith(other.Range);
   }
 
-  bool isAvailableAsSPI() const { return SPI && *SPI; }
-
   /// Returns a representation of this range as a string for debugging purposes.
   std::string getAsString() const {
-    return "AvailabilityContext(" + OSVersion.getAsString() +
-           (isAvailableAsSPI() ? ", spi" : "") + ")";
+    return "AvailabilityContext(" + getVersionString() + ")";
+  }
+
+  /// Returns a representation of the raw version range as a string for
+  /// debugging purposes.
+  std::string getVersionString() const {
+    assert(Range.hasLowerEndpoint());
+    return Range.getLowerEndpoint().getAsString();
   }
 };
 
@@ -358,9 +348,12 @@ class AvailabilityInference {
   static AvailabilityContext inferForType(Type t);
 
   /// Returns the context where a declaration is available
-  ///  We assume a declaration without an annotation is always available.
+  /// We assume a declaration without an annotation is always available.
   static AvailabilityContext availableRange(const Decl *D, ASTContext &C);
 
+  /// Returns true is the declaration is `@_spi_available`.
+  static bool isAvailableAsSPI(const Decl *D, ASTContext &C);
+
   /// Returns the availability context for a declaration with the given
   /// @available attribute.
   ///

lib/AST/ASTContext.cpp

@@ -6782,3 +6782,7 @@ ValueOwnership swift::asValueOwnership(ParameterOwnership o) {
   }
   llvm_unreachable("exhaustive switch");
 }
+
+StringRef ASTContext::getTargetPlatformStringForDiagnostics() const {
+  return prettyPlatformString(targetPlatform(LangOpts));
+}

lib/AST/Availability.cpp

@@ -423,8 +423,7 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
 }
 
 bool Decl::isAvailableAsSPI() const {
-  return AvailabilityInference::availableRange(this, getASTContext())
-    .isAvailableAsSPI();
+  return AvailabilityInference::isAvailableAsSPI(this, getASTContext());
 }
 
 std::optional<AvailableAttrDeclPair>
@@ -518,14 +517,6 @@ bool Decl::requiresUnavailableDeclABICompatibilityStubs() const {
   return isUnreachableAtRuntime();
 }
 
-bool UnavailabilityReason::requiresDeploymentTargetOrEarlier(
-    ASTContext &Ctx) const {
-  return RequiredDeploymentRange.getLowerEndpoint() <=
-         AvailabilityContext::forDeploymentTarget(Ctx)
-             .getOSVersion()
-             .getLowerEndpoint();
-}
-
 AvailabilityContext
 AvailabilityInference::annotatedAvailableRangeForAttr(const SpecializeAttr* attr,
                                                       ASTContext &ctx) {
@@ -550,13 +541,10 @@ AvailabilityInference::annotatedAvailableRangeForAttr(const SpecializeAttr* attr
   return AvailabilityContext::alwaysAvailable();
 }
 
-AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
-                                                          ASTContext &Ctx) {
-  std::optional<AvailabilityContext> AnnotatedRange =
-      annotatedAvailableRange(D, Ctx);
-  if (AnnotatedRange.has_value()) {
-    return AnnotatedRange.value();
-  }
+static const AvailableAttr *attrForAvailableRange(const Decl *D,
+                                                  ASTContext &Ctx) {
+  if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(D, Ctx))
+    return attr;
 
   // Unlike other declarations, extensions can be used without referring to them
   // by name (they don't have one) in the source. For this reason, when checking
@@ -568,16 +556,30 @@ AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
 
   DeclContext *DC = D->getDeclContext();
   if (auto *ED = dyn_cast<ExtensionDecl>(DC)) {
-    AnnotatedRange = annotatedAvailableRange(ED, Ctx);
-    if (AnnotatedRange.has_value()) {
-      return AnnotatedRange.value();
-    }
+    if (auto attr =
+            AvailabilityInference::attrForAnnotatedAvailableRange(ED, Ctx))
+      return attr;
   }
 
+  return nullptr;
+}
+
+AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
+                                                          ASTContext &Ctx) {
+  if (auto attr = attrForAvailableRange(D, Ctx))
+    return availableRange(attr, Ctx);
+
   // Treat unannotated declarations as always available.
   return AvailabilityContext::alwaysAvailable();
 }
 
+bool AvailabilityInference::isAvailableAsSPI(const Decl *D, ASTContext &Ctx) {
+  if (auto attr = attrForAvailableRange(D, Ctx))
+    return attr->IsSPI;
+
+  return false;
+}
+
 AvailabilityContext
 AvailabilityInference::availableRange(const AvailableAttr *attr,
                                       ASTContext &Ctx) {
@@ -590,8 +592,7 @@ AvailabilityInference::availableRange(const AvailableAttr *attr,
       attr, Ctx, Platform, RemappedIntroducedVersion))
     IntroducedVersion = RemappedIntroducedVersion;
 
-  return AvailabilityContext{VersionRange::allGTE(IntroducedVersion),
-                             attr->IsSPI};
+  return AvailabilityContext{VersionRange::allGTE(IntroducedVersion)};
 }
 
 namespace {

lib/AST/TypeRefinementContext.cpp

@@ -360,12 +360,22 @@ TypeRefinementContext::getAvailabilityConditionVersionSourceRange(
   llvm_unreachable("Unhandled Reason in switch.");
 }
 
+static std::string
+stringForAvailability(const AvailabilityContext &availability) {
+  if (availability.isAlwaysAvailable())
+    return "all";
+  if (availability.isKnownUnreachable())
+    return "none";
+
+  return availability.getVersionString();
+}
+
 void TypeRefinementContext::print(raw_ostream &OS, SourceManager &SrcMgr,
                                   unsigned Indent) const {
   OS.indent(Indent);
   OS << "(" << getReasonName(getReason());
 
-  OS << " versions=" << AvailabilityInfo.getOSVersion().getAsString();
+  OS << " version=" << stringForAvailability(AvailabilityInfo);
 
   if (getReason() == Reason::Decl || getReason() == Reason::DeclImplicit) {
     Decl *D = Node.getAsDecl();
@@ -390,8 +400,8 @@ void TypeRefinementContext::print(raw_ostream &OS, SourceManager &SrcMgr,
   }
 
   if (!ExplicitAvailabilityInfo.isAlwaysAvailable())
-    OS << " explicit_versions="
-       << ExplicitAvailabilityInfo.getOSVersion().getAsString();
+    OS << " explicit_version="
+       << stringForAvailability(ExplicitAvailabilityInfo);
 
   for (TypeRefinementContext *Child : Children) {
     OS << '\n';

lib/ClangImporter/ImportDecl.cpp

@@ -540,7 +540,7 @@ static void applyAvailableAttribute(Decl *decl, AvailabilityContext &info,
                                       /*Message=*/StringRef(),
                                       /*Rename=*/StringRef(),
                                       /*RenameDecl=*/nullptr,
-                                      info.getOSVersion().getLowerEndpoint(),
+                                      info.getRawMinimumVersion(),
                                       /*IntroducedRange*/SourceRange(),
                                       /*Deprecated=*/noVersion,
                                       /*DeprecatedRange*/SourceRange(),
@@ -2803,13 +2803,13 @@ namespace {
       if (auto classDecl = dyn_cast<ClassDecl>(result)) {
         validateForeignReferenceType(decl, classDecl);
 
-        auto ctx = Impl.SwiftContext.getSwift58Availability();
-        if (!ctx.isAlwaysAvailable()) {
-          assert(ctx.getOSVersion().hasLowerEndpoint());
+        auto availability = Impl.SwiftContext.getSwift58Availability();
+        if (!availability.isAlwaysAvailable()) {
+          assert(availability.hasMinimumVersion());
           auto AvAttr = new (Impl.SwiftContext) AvailableAttr(
               SourceLoc(), SourceRange(),
               targetPlatform(Impl.SwiftContext.LangOpts), "", "",
-              /*RenameDecl=*/nullptr, ctx.getOSVersion().getLowerEndpoint(),
+              /*RenameDecl=*/nullptr, availability.getRawMinimumVersion(),
               /*IntroducedRange=*/SourceRange(), {},
               /*DeprecatedRange=*/SourceRange(), {},
               /*ObsoletedRange=*/SourceRange(),
@@ -6636,9 +6636,9 @@ bool SwiftDeclConverter::existingConstructorIsWorse(
     if (!introduced.empty())
       return false;
   } else {
-    VersionRange existingIntroduced = existingAvailability.getOSVersion();
-    if (introduced != existingIntroduced.getLowerEndpoint()) {
-      return introduced < existingIntroduced.getLowerEndpoint();
+    auto existingIntroduced = existingAvailability.getRawMinimumVersion();
+    if (introduced != existingIntroduced) {
+      return introduced < existingIntroduced;
     }
   }
 

lib/IRGen/GenMeta.cpp

@@ -5115,9 +5115,9 @@ diagnoseUnsupportedObjCImplLayout(IRGenModule &IGM, ClassDecl *classDecl,
         diags.diagnose(
             field.getVarDecl(),
             diag::attr_objc_implementation_resilient_property_deployment_target,
-            prettyPlatformString(targetPlatform(ctx.LangOpts)),
-            currentAvailability.getOSVersion().getLowerEndpoint(),
-            requiredAvailability.getOSVersion().getLowerEndpoint());
+            ctx.getTargetPlatformStringForDiagnostics(),
+            currentAvailability.getRawMinimumVersion(),
+            requiredAvailability.getRawMinimumVersion());
       else
         diags.diagnose(
             field.getVarDecl(),

lib/SIL/IR/SILPrinter.cpp

@@ -3441,8 +3441,7 @@ void SILFunction::print(SILPrintContext &PrintCtx) const {
     OS << "[weak_imported] ";
   auto availability = getAvailabilityForLinkage();
   if (!availability.isAlwaysAvailable()) {
-    auto version = availability.getOSVersion().getLowerEndpoint();
-    OS << "[available " << version.getAsString() << "] ";
+    OS << "[available " << availability.getVersionString() << "] ";
   }
 
   switch (getInlineStrategy()) {
@@ -4413,9 +4412,8 @@ void SILSpecializeAttr::print(llvm::raw_ostream &OS) const {
   if (targetFunction) {
     OS << "target: \"" << targetFunction->getName() << "\", ";
   }
- if (!availability.isAlwaysAvailable()) {
-    auto version = availability.getOSVersion().getLowerEndpoint();
-    OS << "available: " << version.getAsString() << ", ";
+  if (!availability.isAlwaysAvailable()) {
+    OS << "available: " << availability.getVersionString() << ", ";
   }
   if (!requirements.empty()) {
     OS << "where ";