AST: Remove DeclAttributes::getPotentiallyUnavailable().

This utility duplicated logic that is now meant to be encapsulated by
`getUnsatisfiedAvailabilityConstraint()`.

Author: tshortli

include/swift/AST/Attr.h

@@ -2932,11 +2932,6 @@ class DeclAttributes {
   findMostSpecificActivePlatform(const ASTContext &ctx,
                                  bool ignoreAppExtensions = false) const;
 
-  /// Returns the first @available attribute that indicates
-  /// a declaration is unavailable, or the first one that indicates it's
-  /// potentially unavailable, or null otherwise.
-  const AvailableAttr *getPotentiallyUnavailable(const ASTContext &ctx) const;
-
   /// Returns the first @available attribute that indicates
   /// a declaration is unavailable, or null otherwise.
   const AvailableAttr *getUnavailable(const ASTContext &ctx,

include/swift/AST/AvailabilityConstraint.h

@@ -87,6 +87,10 @@ class AvailabilityConstraint {
   Kind getKind() const { return kind; }
   const AvailableAttr *getAttr() const { return attr; }
 
+  /// Returns the platform that this constraint applies to, or
+  /// `PlatformKind::none` if it is not platform specific.
+  PlatformKind getPlatform() const;
+
   /// Returns the required range for `IntroducedInNewerVersion` requirements, or
   /// `std::nullopt` otherwise.
   std::optional<AvailabilityRange>
@@ -95,6 +99,10 @@ class AvailabilityConstraint {
   /// Returns true if this unmet requirement can be satisfied by introducing an
   /// `if #available(...)` condition in source.
   bool isConditionallySatisfiable() const;
+
+  /// Some availability constraints are active for type-checking but cannot
+  /// be translated directly into an `if #available(...)` runtime query.
+  bool isActiveForRuntimeQueries(ASTContext &ctx) const;
 };
 
 } // end namespace swift

lib/AST/Attr.cpp

@@ -427,48 +427,6 @@ DeclAttributes::findMostSpecificActivePlatform(const ASTContext &ctx,
   return bestAttr;
 }
 
-const AvailableAttr *
-DeclAttributes::getPotentiallyUnavailable(const ASTContext &ctx) const {
-  const AvailableAttr *potential = nullptr;
-  const AvailableAttr *conditional = nullptr;
-
-  for (auto Attr : *this)
-    if (auto AvAttr = dyn_cast<AvailableAttr>(Attr)) {
-      if (AvAttr->isInvalid())
-        continue;
-
-      if (!AvAttr->isActivePlatform(ctx) &&
-          !AvAttr->isLanguageVersionSpecific() &&
-          !AvAttr->isPackageDescriptionVersionSpecific())
-        continue;
-
-      // Definitely not available.
-      if (AvAttr->isUnconditionallyUnavailable())
-        return AvAttr;
-
-      switch (AvAttr->getVersionAvailability(ctx)) {
-      case AvailableVersionComparison::Available:
-        // Doesn't limit the introduced version.
-        break;
-
-      case AvailableVersionComparison::PotentiallyUnavailable:
-        // We'll return this if we don't see something that proves it's
-        // not available in this version.
-        potential = AvAttr;
-        break;
-
-      case AvailableVersionComparison::Unavailable:
-      case AvailableVersionComparison::Obsoleted:
-        conditional = AvAttr;
-        break;
-      }
-    }
-
-  if (conditional)
-    return conditional;
-  return potential;
-}
-
 const AvailableAttr *
 DeclAttributes::getUnavailable(const ASTContext &ctx,
                                bool ignoreAppExtensions) const {

lib/AST/Availability.cpp

@@ -65,6 +65,10 @@ AvailabilityRange AvailabilityRange::forRuntimeTarget(const ASTContext &Ctx) {
   return AvailabilityRange(VersionRange::allGTE(Ctx.LangOpts.RuntimeVersion));
 }
 
+PlatformKind AvailabilityConstraint::getPlatform() const {
+  return attr->Platform;
+}
+
 std::optional<AvailabilityRange>
 AvailabilityConstraint::getRequiredNewerAvailabilityRange(
     ASTContext &ctx) const {
@@ -89,6 +93,15 @@ bool AvailabilityConstraint::isConditionallySatisfiable() const {
   }
 }
 
+bool AvailabilityConstraint::isActiveForRuntimeQueries(ASTContext &ctx) const {
+  if (attr->Platform == PlatformKind::none)
+    return true;
+
+  return swift::isPlatformActive(attr->Platform, ctx.LangOpts,
+                                 /*forTargetVariant=*/false,
+                                 /*forRuntimeQuery=*/true);
+}
+
 namespace {
 
 /// The inferred availability required to access a group of declarations

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -237,38 +237,35 @@ struct RuntimeVersionCheck {
 /// information about the runtime check needed to ensure it is available to
 /// \c versionCheck and returns true.
 static bool
-checkAvailability(const EnumElementDecl *elt, ASTContext &C,
+checkAvailability(const EnumElementDecl *elt, DeclContext *dc,
+                  AvailabilityContext availabilityContext,
                   std::optional<RuntimeVersionCheck> &versionCheck) {
-  auto *attr = elt->getAttrs().getPotentiallyUnavailable(C);
+  auto &C = dc->getASTContext();
+  auto constraint =
+      getUnsatisfiedAvailabilityConstraint(elt, dc, availabilityContext);
 
   // Is it always available?
-  if (!attr)
+  if (!constraint)
     return true;
 
-  // For type-checking purposes, iOS availability is inherited for visionOS
-  // targets. However, it is not inherited for the sake of code-generation
-  // of runtime availability queries, and is assumed to be available.
-  if ((attr->Platform == PlatformKind::iOS ||
-       attr->Platform == PlatformKind::iOSApplicationExtension) &&
-      C.LangOpts.Target.isXROS())
+  // Some constraints are active for type checking but can't translate to
+  // runtime restrictions.
+  if (!constraint->isActiveForRuntimeQueries(C))
     return true;
 
-  AvailableVersionComparison availability = attr->getVersionAvailability(C);
-
-  assert(availability != AvailableVersionComparison::Available &&
-         "DeclAttributes::getPotentiallyUnavailable() shouldn't "
-         "return an available attribute");
-
   // Is it never available?
-  if (availability != AvailableVersionComparison::PotentiallyUnavailable)
+  if (!constraint->isConditionallySatisfiable())
     return false;
 
   // It's conditionally available; create a version constraint and return true.
-  assert(attr->getPlatformAgnosticAvailability() ==
-             PlatformAgnosticAvailabilityKind::None &&
-         "can only express #available(somePlatform version) checks");
-  versionCheck.emplace(attr->Platform, *attr->Introduced);
+  auto platform = constraint->getPlatform();
+  auto range = constraint->getRequiredNewerAvailabilityRange(C);
+
+  // Only platform version constraints are supported currently.
+  ASSERT(platform != PlatformKind::none);
+  ASSERT(range);
 
+  versionCheck.emplace(platform, range->getRawMinimumVersion());
   return true;
 }
 
@@ -295,6 +292,7 @@ deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
 
   auto parentDC = initDecl->getDeclContext();
   ASTContext &C = parentDC->getASTContext();
+  auto availabilityContext = AvailabilityContext::forDeploymentTarget(C);
 
   auto nominalTypeDecl = parentDC->getSelfNominalTypeDecl();
   auto enumDecl = cast<EnumDecl>(nominalTypeDecl);
@@ -318,7 +316,7 @@ deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
     // information about that check in versionCheck and keep processing this
     // element.
     std::optional<RuntimeVersionCheck> versionCheck(std::nullopt);
-    if (!checkAvailability(elt, C, versionCheck))
+    if (!checkAvailability(elt, parentDC, availabilityContext, versionCheck))
       continue;
 
     // litPat = elt.rawValueExpr as a pattern