AST: Move UnmetAvailabilityRequirement to Availability.h.

This type will need to be used outside of Sema.

Author: tshortli

include/swift/AST/Availability.h

@@ -335,6 +335,74 @@ 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;
+};
+
 class AvailabilityInference {
 public:
   /// Returns the decl that should be considered the parent decl of the given

lib/AST/Availability.cpp

@@ -64,6 +64,19 @@ AvailabilityRange AvailabilityRange::forRuntimeTarget(const ASTContext &Ctx) {
   return AvailabilityRange(VersionRange::allGTE(Ctx.LangOpts.RuntimeVersion));
 }
 
+std::optional<AvailabilityRange>
+UnmetAvailabilityRequirement::getRequiredNewerAvailabilityRange(
+    ASTContext &ctx) const {
+  switch (kind) {
+  case Kind::AlwaysUnavailable:
+  case Kind::RequiresVersion:
+  case Kind::Obsoleted:
+    return std::nullopt;
+  case Kind::IntroducedInNewerVersion:
+    return AvailabilityInference::availableRange(attr, ctx);
+  }
+}
+
 namespace {
 
 /// The inferred availability required to access a group of declarations

lib/Sema/TypeCheckAvailability.cpp

@@ -316,19 +316,6 @@ ExportContext::getExportabilityReason() const {
   return std::nullopt;
 }
 
-std::optional<AvailabilityRange>
-UnmetAvailabilityRequirement::getRequiredNewerAvailabilityRange(
-    ASTContext &ctx) const {
-  switch (kind) {
-  case Kind::AlwaysUnavailable:
-  case Kind::RequiresVersion:
-  case Kind::Obsoleted:
-    return std::nullopt;
-  case Kind::IntroducedInNewerVersion:
-    return AvailabilityInference::availableRange(attr, ctx);
-  }
-}
-
 /// Returns the first availability attribute on the declaration that is active
 /// on the target platform.
 static const AvailableAttr *getActiveAvailableAttribute(const Decl *D,

lib/Sema/TypeCheckAvailability.h

@@ -200,74 +200,6 @@ class ExportContext {
   const AvailableAttr *shouldDiagnoseDeclAsUnavailable(const Decl *decl) const;
 };
 
-/// 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;
-};
-
 /// Check if a declaration is exported as part of a module's external interface.
 /// This includes public and @usableFromInline decls.
 bool isExported(const ValueDecl *VD);