AST: Rename AvailabilityConstraint::Kind to Reason.

NFC.

Author: tshortli

include/swift/AST/AvailabilityConstraint.h

@@ -33,23 +33,23 @@ class Decl;
 /// certain context.
 class AvailabilityConstraint {
 public:
-  enum class Kind {
+  enum class Reason {
     /// The declaration is referenced in a context in which it is generally
     /// unavailable. For example, a reference to a declaration that is
     /// unavailable on macOS from a context that may execute on macOS has this
     /// constraint.
-    AlwaysUnavailable,
+    UnconditionallyUnavailable,
 
     /// The declaration is referenced in a context in which it is considered
     /// obsolete. For example, a reference to a declaration that is obsolete in
     /// macOS 13 from a context that may execute on macOS 13 or later has this
     /// constraint.
     Obsoleted,
 
-    /// The declaration is only available in a different version. For example,
+    /// The declaration is only available in a later version. For example,
     /// the declaration might only be introduced in the Swift 6 language mode
     /// while the module is being compiled in the Swift 5 language mode.
-    RequiresVersion,
+    IntroducedInLaterVersion,
 
     /// The declaration is referenced in a context that does not have an
     /// adequate minimum version constraint. For example, a reference to a
@@ -58,37 +58,39 @@ class AvailabilityConstraint {
     /// kind of constraint can be satisfied by tightening the minimum
     /// version of the context with `if #available(...)` or by adding or
     /// adjusting an `@available` attribute.
-    IntroducedInNewerVersion,
+    IntroducedInLaterDynamicVersion,
   };
 
 private:
-  llvm::PointerIntPair<SemanticAvailableAttr, 2, Kind> attrAndKind;
+  llvm::PointerIntPair<SemanticAvailableAttr, 2, Reason> attrAndReason;
 
-  AvailabilityConstraint(Kind kind, SemanticAvailableAttr attr)
-      : attrAndKind(attr, kind) {};
+  AvailabilityConstraint(Reason reason, SemanticAvailableAttr attr)
+      : attrAndReason(attr, reason) {};
 
 public:
   static AvailabilityConstraint
-  forAlwaysUnavailable(SemanticAvailableAttr attr) {
-    return AvailabilityConstraint(Kind::AlwaysUnavailable, attr);
+  unconditionallyUnavailable(SemanticAvailableAttr attr) {
+    return AvailabilityConstraint(Reason::UnconditionallyUnavailable, attr);
   }
 
-  static AvailabilityConstraint forObsoleted(SemanticAvailableAttr attr) {
-    return AvailabilityConstraint(Kind::Obsoleted, attr);
+  static AvailabilityConstraint obsoleted(SemanticAvailableAttr attr) {
+    return AvailabilityConstraint(Reason::Obsoleted, attr);
   }
 
-  static AvailabilityConstraint forRequiresVersion(SemanticAvailableAttr attr) {
-    return AvailabilityConstraint(Kind::RequiresVersion, attr);
+  static AvailabilityConstraint
+  introducedInLaterVersion(SemanticAvailableAttr attr) {
+    return AvailabilityConstraint(Reason::IntroducedInLaterVersion, attr);
   }
 
   static AvailabilityConstraint
-  forIntroducedInNewerVersion(SemanticAvailableAttr attr) {
-    return AvailabilityConstraint(Kind::IntroducedInNewerVersion, attr);
+  introducedInLaterDynamicVersion(SemanticAvailableAttr attr) {
+    return AvailabilityConstraint(Reason::IntroducedInLaterDynamicVersion,
+                                  attr);
   }
 
-  Kind getKind() const { return attrAndKind.getInt(); }
+  Reason getReason() const { return attrAndReason.getInt(); }
   SemanticAvailableAttr getAttr() const {
-    return static_cast<SemanticAvailableAttr>(attrAndKind.getPointer());
+    return static_cast<SemanticAvailableAttr>(attrAndReason.getPointer());
   }
 
   /// Returns the domain that the constraint applies to.

lib/AST/AvailabilityConstraint.cpp

@@ -25,23 +25,23 @@ PlatformKind AvailabilityConstraint::getPlatform() const {
 std::optional<AvailabilityRange>
 AvailabilityConstraint::getRequiredNewerAvailabilityRange(
     ASTContext &ctx) const {
-  switch (getKind()) {
-  case Kind::AlwaysUnavailable:
-  case Kind::RequiresVersion:
-  case Kind::Obsoleted:
+  switch (getReason()) {
+  case Reason::UnconditionallyUnavailable:
+  case Reason::Obsoleted:
+  case Reason::IntroducedInLaterVersion:
     return std::nullopt;
-  case Kind::IntroducedInNewerVersion:
+  case Reason::IntroducedInLaterDynamicVersion:
     return getAttr().getIntroducedRange(ctx);
   }
 }
 
 bool AvailabilityConstraint::isConditionallySatisfiable() const {
-  switch (getKind()) {
-  case Kind::AlwaysUnavailable:
-  case Kind::RequiresVersion:
-  case Kind::Obsoleted:
+  switch (getReason()) {
+  case Reason::UnconditionallyUnavailable:
+  case Reason::Obsoleted:
+  case Reason::IntroducedInLaterVersion:
     return false;
-  case Kind::IntroducedInNewerVersion:
+  case Reason::IntroducedInLaterDynamicVersion:
     return true;
   }
 }
@@ -84,7 +84,7 @@ swift::getAvailabilityConstraintForAttr(const Decl *decl,
     return std::nullopt;
 
   if (attr.isUnconditionallyUnavailable())
-    return AvailabilityConstraint::forAlwaysUnavailable(attr);
+    return AvailabilityConstraint::unconditionallyUnavailable(attr);
 
   auto &ctx = decl->getASTContext();
   auto deploymentVersion = attr.getActiveVersion(ctx);
@@ -101,16 +101,16 @@ swift::getAvailabilityConstraintForAttr(const Decl *decl,
   }
 
   if (obsoletedVersion && *obsoletedVersion <= deploymentVersion)
-    return AvailabilityConstraint::forObsoleted(attr);
+    return AvailabilityConstraint::obsoleted(attr);
 
   AvailabilityRange introducedRange = attr.getIntroducedRange(ctx);
 
   // FIXME: [availability] Expand this to cover custom versioned domains
   if (attr.isPlatformSpecific()) {
     if (!context.getPlatformRange().isContainedIn(introducedRange))
-      return AvailabilityConstraint::forIntroducedInNewerVersion(attr);
+      return AvailabilityConstraint::introducedInLaterDynamicVersion(attr);
   } else if (!deploymentRange.isContainedIn(introducedRange)) {
-    return AvailabilityConstraint::forRequiresVersion(attr);
+    return AvailabilityConstraint::introducedInLaterVersion(attr);
   }
 
   return std::nullopt;

lib/AST/AvailabilityContext.cpp

@@ -71,13 +71,13 @@ bool AvailabilityContext::Info::constrainWith(
   for (auto constraint : constraints) {
     auto attr = constraint.getAttr();
     auto domain = attr.getDomain();
-    switch (constraint.getKind()) {
-    case AvailabilityConstraint::Kind::AlwaysUnavailable:
-    case AvailabilityConstraint::Kind::Obsoleted:
-    case AvailabilityConstraint::Kind::RequiresVersion:
+    switch (constraint.getReason()) {
+    case AvailabilityConstraint::Reason::UnconditionallyUnavailable:
+    case AvailabilityConstraint::Reason::Obsoleted:
+    case AvailabilityConstraint::Reason::IntroducedInLaterVersion:
       isConstrained |= constrainUnavailability(domain);
       break;
-    case AvailabilityConstraint::Kind::IntroducedInNewerVersion:
+    case AvailabilityConstraint::Reason::IntroducedInLaterDynamicVersion:
       // FIXME: [availability] Support versioning for other kinds of domains.
       DEBUG_ASSERT(domain.isPlatform());
       if (domain.isPlatform())

lib/Sema/TypeCheckAvailability.cpp

@@ -3012,12 +3012,12 @@ bool shouldHideDomainNameForConstraintDiagnostic(
 
   case AvailabilityDomain::Kind::PackageDescription:
   case AvailabilityDomain::Kind::SwiftLanguage:
-    switch (constraint.getKind()) {
-    case AvailabilityConstraint::Kind::AlwaysUnavailable:
-    case AvailabilityConstraint::Kind::IntroducedInNewerVersion:
+    switch (constraint.getReason()) {
+    case AvailabilityConstraint::Reason::UnconditionallyUnavailable:
+    case AvailabilityConstraint::Reason::IntroducedInLaterVersion:
       return false;
-    case AvailabilityConstraint::Kind::RequiresVersion:
-    case AvailabilityConstraint::Kind::Obsoleted:
+    case AvailabilityConstraint::Reason::IntroducedInLaterDynamicVersion:
+    case AvailabilityConstraint::Reason::Obsoleted:
       return true;
     }
   }
@@ -3061,24 +3061,24 @@ bool diagnoseExplicitUnavailability(SourceLoc loc,
       .limitBehaviorWithPreconcurrency(behavior, preconcurrency)
       .warnUntilSwiftVersionIf(warnIfConformanceUnavailablePreSwift6, 6);
 
-  switch (constraint.getKind()) {
-  case AvailabilityConstraint::Kind::AlwaysUnavailable:
+  switch (constraint.getReason()) {
+  case AvailabilityConstraint::Reason::UnconditionallyUnavailable:
     diags
         .diagnose(ext, diag::conformance_availability_marked_unavailable, type,
                   proto)
         .highlight(attr.getParsedAttr()->getRange());
     break;
-  case AvailabilityConstraint::Kind::RequiresVersion:
+  case AvailabilityConstraint::Reason::IntroducedInLaterVersion:
     diags.diagnose(ext, diag::conformance_availability_introduced_in_version,
                    type, proto, versionedPlatform, *attr.getIntroduced());
     break;
-  case AvailabilityConstraint::Kind::Obsoleted:
+  case AvailabilityConstraint::Reason::Obsoleted:
     diags
         .diagnose(ext, diag::conformance_availability_obsoleted, type, proto,
                   versionedPlatform, *attr.getObsoleted())
         .highlight(attr.getParsedAttr()->getRange());
     break;
-  case AvailabilityConstraint::Kind::IntroducedInNewerVersion:
+  case AvailabilityConstraint::Reason::IntroducedInLaterDynamicVersion:
     llvm_unreachable("unexpected constraint");
   }
   return true;
@@ -3107,20 +3107,21 @@ swift::getUnsatisfiedAvailabilityConstraint(
       if ((attr->isSwiftLanguageModeSpecific() ||
            attr->isPackageDescriptionVersionSpecific()) &&
           attr->getIntroduced().has_value())
-        return AvailabilityConstraint::forRequiresVersion(*attr);
+        return AvailabilityConstraint::introducedInLaterVersion(*attr);
 
-      return AvailabilityConstraint::forAlwaysUnavailable(*attr);
+      return AvailabilityConstraint::unconditionallyUnavailable(*attr);
 
     case AvailableVersionComparison::Obsoleted:
-      return AvailabilityConstraint::forObsoleted(*attr);
+      return AvailabilityConstraint::obsoleted(*attr);
     }
   }
 
   // Check whether the declaration is available in a newer platform version.
   if (auto rangeAttr = decl->getAvailableAttrForPlatformIntroduction()) {
     auto range = rangeAttr->getIntroducedRange(ctx);
     if (!availabilityContext.getPlatformRange().isContainedIn(range))
-      return AvailabilityConstraint::forIntroducedInNewerVersion(*rangeAttr);
+      return AvailabilityConstraint::introducedInLaterDynamicVersion(
+          *rangeAttr);
   }
 
   return std::nullopt;
@@ -3526,24 +3527,24 @@ bool diagnoseExplicitUnavailability(
   }
 
   auto sourceRange = Attr.getParsedAttr()->getRange();
-  switch (constraint.getKind()) {
-  case AvailabilityConstraint::Kind::AlwaysUnavailable:
+  switch (constraint.getReason()) {
+  case AvailabilityConstraint::Reason::UnconditionallyUnavailable:
     diags.diagnose(D, diag::availability_marked_unavailable, D)
         .highlight(sourceRange);
     break;
-  case AvailabilityConstraint::Kind::RequiresVersion:
+  case AvailabilityConstraint::Reason::IntroducedInLaterVersion:
     diags
         .diagnose(D, diag::availability_introduced_in_version, D,
                   versionedPlatform, *Attr.getIntroduced())
         .highlight(sourceRange);
     break;
-  case AvailabilityConstraint::Kind::Obsoleted:
+  case AvailabilityConstraint::Reason::Obsoleted:
     diags
         .diagnose(D, diag::availability_obsoleted, D, versionedPlatform,
                   *Attr.getObsoleted())
         .highlight(sourceRange);
     break;
-  case AvailabilityConstraint::Kind::IntroducedInNewerVersion:
+  case AvailabilityConstraint::Reason::IntroducedInLaterDynamicVersion:
     llvm_unreachable("unexpected constraint");
     break;
   }