AST: Rename UnmetAvailabilityRequirement to AvailabilityConstraint.

Also, pull its definition out into a separate header.

Author: tshortli

include/swift/AST/Availability.h

@@ -335,78 +335,6 @@ class AvailabilityRange {
   }
 };
 
-/// Represents the reason a declaration is considered unavailable in a certain
-/// context.
-class UnmetAvailabilityRequirement {
-public:
-  enum class Kind {
-    /// 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
-    /// unmet requirement.
-    AlwaysUnavailable,
-
-    /// 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
-    /// unmet requirement.
-    Obsoleted,
-
-    /// The declaration is only available in a different 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,
-
-    /// The declaration is referenced in a context that does not have an
-    /// adequate minimum version constraint. For example, a reference to a
-    /// declaration that is introduced in macOS 13 from a context that may
-    /// execute on earlier versions of macOS has this unmet requirement. This
-    /// kind of unmet requirement can be addressed by tightening the minimum
-    /// version of the context with `if #available(...)` or by adding or
-    /// adjusting an `@available` attribute.
-    IntroducedInNewerVersion,
-  };
-
-private:
-  Kind kind;
-  const AvailableAttr *attr;
-
-  UnmetAvailabilityRequirement(Kind kind, const AvailableAttr *attr)
-      : kind(kind), attr(attr){};
-
-public:
-  static UnmetAvailabilityRequirement
-  forAlwaysUnavailable(const AvailableAttr *attr) {
-    return UnmetAvailabilityRequirement(Kind::AlwaysUnavailable, attr);
-  }
-
-  static UnmetAvailabilityRequirement forObsoleted(const AvailableAttr *attr) {
-    return UnmetAvailabilityRequirement(Kind::Obsoleted, attr);
-  }
-
-  static UnmetAvailabilityRequirement
-  forRequiresVersion(const AvailableAttr *attr) {
-    return UnmetAvailabilityRequirement(Kind::RequiresVersion, attr);
-  }
-
-  static UnmetAvailabilityRequirement
-  forIntroducedInNewerVersion(const AvailableAttr *attr) {
-    return UnmetAvailabilityRequirement(Kind::IntroducedInNewerVersion, attr);
-  }
-
-  Kind getKind() const { return kind; }
-  const AvailableAttr *getAttr() const { return attr; }
-
-  /// Returns the required range for `IntroducedInNewerVersion` requirements, or
-  /// `std::nullopt` otherwise.
-  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;
-};
-
 class AvailabilityInference {
 public:
   /// Returns the decl that should be considered the parent decl of the given

include/swift/AST/AvailabilityConstraint.h

@@ -0,0 +1,102 @@
+//===--- AvailabilityConstraint.h - Swift Availability Constraints ------*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the AvailabilityConstraint class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_AVAILABILITY_CONSTRAINT_H
+#define SWIFT_AST_AVAILABILITY_CONSTRAINT_H
+
+#include "swift/AST/Availability.h"
+#include "swift/AST/PlatformKind.h"
+#include "swift/Basic/LLVM.h"
+
+namespace swift {
+
+class ASTContext;
+class AvailableAttr;
+
+/// Represents the reason a declaration could be considered unavailable in a
+/// certain context.
+class AvailabilityConstraint {
+public:
+  enum class Kind {
+    /// 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,
+
+    /// 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 might only be introduced in the Swift 6 language mode
+    /// while the module is being compiled in the Swift 5 language mode.
+    RequiresVersion,
+
+    /// The declaration is referenced in a context that does not have an
+    /// adequate minimum version constraint. For example, a reference to a
+    /// declaration that is introduced in macOS 13 from a context that may
+    /// execute on earlier versions of macOS has this constraint. This
+    /// 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,
+  };
+
+private:
+  Kind kind;
+  const AvailableAttr *attr;
+
+  AvailabilityConstraint(Kind kind, const AvailableAttr *attr)
+      : kind(kind), attr(attr) {};
+
+public:
+  static AvailabilityConstraint
+  forAlwaysUnavailable(const AvailableAttr *attr) {
+    return AvailabilityConstraint(Kind::AlwaysUnavailable, attr);
+  }
+
+  static AvailabilityConstraint forObsoleted(const AvailableAttr *attr) {
+    return AvailabilityConstraint(Kind::Obsoleted, attr);
+  }
+
+  static AvailabilityConstraint forRequiresVersion(const AvailableAttr *attr) {
+    return AvailabilityConstraint(Kind::RequiresVersion, attr);
+  }
+
+  static AvailabilityConstraint
+  forIntroducedInNewerVersion(const AvailableAttr *attr) {
+    return AvailabilityConstraint(Kind::IntroducedInNewerVersion, attr);
+  }
+
+  Kind getKind() const { return kind; }
+  const AvailableAttr *getAttr() const { return attr; }
+
+  /// Returns the required range for `IntroducedInNewerVersion` requirements, or
+  /// `std::nullopt` otherwise.
+  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;
+};
+
+} // end namespace swift
+
+#endif

lib/AST/Availability.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/Availability.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Attr.h"
+#include "swift/AST/AvailabilityConstraint.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/PlatformKind.h"
 #include "swift/AST/TypeCheckRequests.h"
@@ -65,7 +66,7 @@ AvailabilityRange AvailabilityRange::forRuntimeTarget(const ASTContext &Ctx) {
 }
 
 std::optional<AvailabilityRange>
-UnmetAvailabilityRequirement::getRequiredNewerAvailabilityRange(
+AvailabilityConstraint::getRequiredNewerAvailabilityRange(
     ASTContext &ctx) const {
   switch (kind) {
   case Kind::AlwaysUnavailable:
@@ -77,7 +78,7 @@ UnmetAvailabilityRequirement::getRequiredNewerAvailabilityRange(
   }
 }
 
-bool UnmetAvailabilityRequirement::isConditionallySatisfiable() const {
+bool AvailabilityConstraint::isConditionallySatisfiable() const {
   switch (kind) {
   case Kind::AlwaysUnavailable:
   case Kind::RequiresVersion:

lib/Sema/TypeCheckAvailability.cpp

@@ -3032,7 +3032,7 @@ bool diagnoseExplicitUnavailability(
   return true;
 }
 
-std::optional<UnmetAvailabilityRequirement>
+std::optional<AvailabilityConstraint>
 swift::getUnmetDeclAvailabilityRequirement(
     const Decl *decl, const DeclContext *declContext,
     AvailabilityContext availabilityContext) {
@@ -3056,25 +3056,25 @@ swift::getUnmetDeclAvailabilityRequirement(
       if ((attr->isLanguageVersionSpecific() ||
            attr->isPackageDescriptionVersionSpecific()) &&
           attr->Introduced.has_value())
-        return UnmetAvailabilityRequirement::forRequiresVersion(attr);
+        return AvailabilityConstraint::forRequiresVersion(attr);
 
-      return UnmetAvailabilityRequirement::forAlwaysUnavailable(attr);
+      return AvailabilityConstraint::forAlwaysUnavailable(attr);
 
     case AvailableVersionComparison::Obsoleted:
-      return UnmetAvailabilityRequirement::forObsoleted(attr);
+      return AvailabilityConstraint::forObsoleted(attr);
     }
   }
 
   // Check whether the declaration is available in a newer platform version.
   auto rangeAndAttr = AvailabilityInference::availableRangeAndAttr(decl);
   if (!availabilityContext.getPlatformRange().isContainedIn(rangeAndAttr.first))
-    return UnmetAvailabilityRequirement::forIntroducedInNewerVersion(
+    return AvailabilityConstraint::forIntroducedInNewerVersion(
         rangeAndAttr.second);
 
   return std::nullopt;
 }
 
-std::optional<UnmetAvailabilityRequirement>
+std::optional<AvailabilityConstraint>
 swift::getUnmetDeclAvailabilityRequirement(const Decl *decl,
                                            const DeclContext *referenceDC,
                                            SourceLoc referenceLoc) {

lib/Sema/TypeCheckAvailability.h

@@ -14,6 +14,7 @@
 #define SWIFT_SEMA_TYPE_CHECK_AVAILABILITY_H
 
 #include "swift/AST/AttrKind.h"
+#include "swift/AST/AvailabilityConstraint.h"
 #include "swift/AST/AvailabilityContext.h"
 #include "swift/AST/DeclContext.h"
 #include "swift/AST/Identifier.h"
@@ -247,7 +248,7 @@ void diagnoseOverrideOfUnavailableDecl(ValueDecl *override,
 /// to in the given declaration context and availability context and, if so,
 /// returns a result that describes the unmet availability requirements.
 /// Returns `std::nullopt` if the declaration is available.
-std::optional<UnmetAvailabilityRequirement>
+std::optional<AvailabilityConstraint>
 getUnmetDeclAvailabilityRequirement(const Decl *decl,
                                     const DeclContext *declContext,
                                     AvailabilityContext availabilityContext);
@@ -256,7 +257,7 @@ getUnmetDeclAvailabilityRequirement(const Decl *decl,
 /// to at the given source location in the given decl context and, if so,
 /// returns a result that describes the unmet availability requirements.
 /// Returns `std::nullopt` if the declaration is available.
-std::optional<UnmetAvailabilityRequirement> getUnmetDeclAvailabilityRequirement(
+std::optional<AvailabilityConstraint> getUnmetDeclAvailabilityRequirement(
     const Decl *decl, const DeclContext *referenceDC, SourceLoc referenceLoc);
 
 /// Diagnose uses of the runtime support of the given type, such as