AST: Re-introduce AvailabilityConstraint::Kind.

Now the Kind enum classifies availability constraints based on their
satisfiablility.

NFC.

Author: tshortli

include/swift/AST/AvailabilityConstraint.h

@@ -61,6 +61,16 @@ class AvailabilityConstraint {
     IntroducedInLaterDynamicVersion,
   };
 
+  /// Classifies constraints into different high level categories.
+  enum class Kind {
+    /// There are no contexts in which the declaration would be available.
+    Unavailable,
+
+    /// There are some contexts in which the declaration would be available if
+    /// additional constraints were added.
+    PotentiallyAvailable,
+  };
+
 private:
   llvm::PointerIntPair<SemanticAvailableAttr, 2, Reason> attrAndReason;
 
@@ -93,6 +103,26 @@ class AvailabilityConstraint {
     return static_cast<SemanticAvailableAttr>(attrAndReason.getPointer());
   }
 
+  Kind getKind() const {
+    switch (getReason()) {
+    case Reason::UnconditionallyUnavailable:
+    case Reason::Obsoleted:
+    case Reason::IntroducedInLaterVersion:
+      return Kind::Unavailable;
+    case Reason::IntroducedInLaterDynamicVersion:
+      return Kind::PotentiallyAvailable;
+    }
+  }
+
+  /// Returns true if the constraint cannot be satisfied at runtime.
+  bool isUnavailable() const { return getKind() == Kind::Unavailable; }
+
+  /// Returns true if the constraint is unsatisfied but could be satisfied at
+  /// runtime in a more constrained context.
+  bool isPotentiallyAvailable() const {
+    return getKind() == Kind::PotentiallyAvailable;
+  }
+
   /// Returns the domain that the constraint applies to.
   AvailabilityDomain getDomain() const { return getAttr().getDomain(); }
 
@@ -105,10 +135,6 @@ class AvailabilityConstraint {
   std::optional<AvailabilityRange>
   getRequiredNewerAvailabilityRange(ASTContext &ctx) const;
 
-  /// 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;

lib/AST/AvailabilityConstraint.cpp

@@ -35,17 +35,6 @@ AvailabilityConstraint::getRequiredNewerAvailabilityRange(
   }
 }
 
-bool AvailabilityConstraint::isConditionallySatisfiable() const {
-  switch (getReason()) {
-  case Reason::UnconditionallyUnavailable:
-  case Reason::Obsoleted:
-  case Reason::IntroducedInLaterVersion:
-    return false;
-  case Reason::IntroducedInLaterDynamicVersion:
-    return true;
-  }
-}
-
 bool AvailabilityConstraint::isActiveForRuntimeQueries(ASTContext &ctx) const {
   if (getAttr().getPlatform() == PlatformKind::none)
     return true;

lib/Sema/CSSyntacticElement.cpp

@@ -2467,7 +2467,7 @@ class ResultBuilderRewriter : public SyntacticElementSolutionApplication {
 
       auto constraint = getUnsatisfiedAvailabilityConstraint(
           nominal, context.getAsDeclContext(), loc);
-      if (constraint && constraint->isConditionallySatisfiable()) {
+      if (constraint && constraint->isPotentiallyAvailable()) {
         auto &ctx = getASTContext();
         ctx.Diags.diagnose(loc,
                            diag::result_builder_missing_limited_availability,

lib/Sema/ConstraintSystem.cpp

@@ -4918,11 +4918,11 @@ bool ConstraintSystem::isReadOnlyKeyPathComponent(
   // If the setter is unavailable, then the keypath ought to be read-only
   // in this context.
   if (auto setter = storage->getOpaqueAccessor(AccessorKind::Set)) {
-    // FIXME: Fully unavailable setters should cause the key path to be
-    // readonly too.
+    // FIXME: [availability] Fully unavailable setters should cause the key path
+    // to be readonly too.
     auto constraint =
         getUnsatisfiedAvailabilityConstraint(setter, DC, referenceLoc);
-    if (constraint && constraint->isConditionallySatisfiable())
+    if (constraint && constraint->isPotentiallyAvailable())
       return true;
   }
 

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -248,15 +248,15 @@ checkAvailability(const EnumElementDecl *elt,
   if (!constraint)
     return true;
 
+  // Is it never available?
+  if (constraint->isUnavailable())
+    return false;
+
   // Some constraints are active for type checking but can't translate to
   // runtime restrictions.
   if (!constraint->isActiveForRuntimeQueries(C))
     return true;
 
-  // Is it never available?
-  if (!constraint->isConditionallySatisfiable())
-    return false;
-
   // It's conditionally available; create a version constraint and return true.
   auto platform = constraint->getPlatform();
   auto range = constraint->getRequiredNewerAvailabilityRange(C);

lib/Sema/TypeCheckAvailability.cpp

@@ -3030,7 +3030,7 @@ bool diagnoseExplicitUnavailability(SourceLoc loc,
                                     const ExportContext &where,
                                     bool warnIfConformanceUnavailablePreSwift6,
                                     bool preconcurrency) {
-  if (constraint.isConditionallySatisfiable())
+  if (!constraint.isUnavailable())
     return false;
 
   // Invertible protocols are never unavailable.
@@ -3463,7 +3463,7 @@ bool diagnoseExplicitUnavailability(
     const ExportContext &Where, DeclAvailabilityFlags Flags,
     llvm::function_ref<void(InFlightDiagnostic &, StringRef)>
         attachRenameFixIts) {
-  if (constraint.isConditionallySatisfiable())
+  if (!constraint.isUnavailable())
     return false;
 
   auto Attr = constraint.getAttr();

lib/Sema/TypeCheckPattern.cpp

@@ -41,7 +41,7 @@ static EnumElementDecl *extractEnumElement(DeclContext *DC, SourceLoc UseLoc,
   if (auto constraint =
           getUnsatisfiedAvailabilityConstraint(constant, DC, UseLoc)) {
     // Only diagnose explicit unavailability.
-    if (!constraint->isConditionallySatisfiable())
+    if (constraint->isUnavailable())
       diagnoseDeclAvailability(constant, UseLoc, nullptr,
                                ExportContext::forFunctionBody(DC, UseLoc));
   }