Merge pull request #77384 from tshortli/rename-unmet-availability-requirement

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/BuilderTransform.cpp

@@ -1318,7 +1318,7 @@ ResultBuilderOpSupport TypeChecker::checkBuilderOpSupport(
 
   auto isUnavailable = [&](Decl *D) -> bool {
     auto loc = extractNearestSourceLoc(dc);
-    return getUnmetDeclAvailabilityRequirement(D, dc, loc).has_value();
+    return getUnsatisfiedAvailabilityConstraint(D, dc, loc).has_value();
   };
 
   bool foundMatch = false;

lib/Sema/CSSyntacticElement.cpp

@@ -2475,9 +2475,9 @@ class ResultBuilderRewriter : public SyntacticElementSolutionApplication {
       if (!nominal)
         return false;
 
-      auto unmetRequirement = getUnmetDeclAvailabilityRequirement(
+      auto constraint = getUnsatisfiedAvailabilityConstraint(
           nominal, context.getAsDeclContext(), loc);
-      if (unmetRequirement && unmetRequirement->isConditionallySatisfiable()) {
+      if (constraint && constraint->isConditionallySatisfiable()) {
         auto &ctx = getASTContext();
         ctx.Diags.diagnose(loc,
                            diag::result_builder_missing_limited_availability,

lib/Sema/ConstraintSystem.cpp

@@ -4682,7 +4682,7 @@ bool ConstraintSystem::isDeclUnavailable(const Decl *D,
       loc = getLoc(anchor);
   }
 
-  return getUnmetDeclAvailabilityRequirement(D, DC, loc).has_value();
+  return getUnsatisfiedAvailabilityConstraint(D, DC, loc).has_value();
 }
 
 bool ConstraintSystem::isConformanceUnavailable(ProtocolConformanceRef conformance,
@@ -4881,9 +4881,9 @@ bool ConstraintSystem::isReadOnlyKeyPathComponent(
   if (auto setter = storage->getOpaqueAccessor(AccessorKind::Set)) {
     // FIXME: Fully unavailable setters should cause the key path to be
     // readonly too.
-    auto unmetRequirement =
-        getUnmetDeclAvailabilityRequirement(setter, DC, referenceLoc);
-    if (unmetRequirement && unmetRequirement->isConditionallySatisfiable())
+    auto constraint =
+        getUnsatisfiedAvailabilityConstraint(setter, DC, referenceLoc);
+    if (constraint && constraint->isConditionallySatisfiable())
       return true;
   }
 

lib/Sema/TypeCheckAvailability.cpp

@@ -3032,8 +3032,8 @@ bool diagnoseExplicitUnavailability(
   return true;
 }
 
-std::optional<UnmetAvailabilityRequirement>
-swift::getUnmetDeclAvailabilityRequirement(
+std::optional<AvailabilityConstraint>
+swift::getUnsatisfiedAvailabilityConstraint(
     const Decl *decl, const DeclContext *declContext,
     AvailabilityContext availabilityContext) {
   auto &ctx = declContext->getASTContext();
@@ -3056,29 +3056,29 @@ 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>
-swift::getUnmetDeclAvailabilityRequirement(const Decl *decl,
-                                           const DeclContext *referenceDC,
-                                           SourceLoc referenceLoc) {
-  return getUnmetDeclAvailabilityRequirement(
+std::optional<AvailabilityConstraint>
+swift::getUnsatisfiedAvailabilityConstraint(const Decl *decl,
+                                            const DeclContext *referenceDC,
+                                            SourceLoc referenceLoc) {
+  return getUnsatisfiedAvailabilityConstraint(
       decl, referenceDC,
       TypeChecker::availabilityAtLocation(referenceLoc, referenceDC));
 }
@@ -4094,10 +4094,10 @@ bool swift::diagnoseDeclAvailability(const ValueDecl *D, SourceRange R,
   auto *DC = Where.getDeclContext();
   auto &ctx = DC->getASTContext();
 
-  auto unmetRequirement =
-      getUnmetDeclAvailabilityRequirement(D, DC, Where.getAvailability());
+  auto constraint =
+      getUnsatisfiedAvailabilityConstraint(D, DC, Where.getAvailability());
 
-  if (unmetRequirement && !unmetRequirement->isConditionallySatisfiable()) {
+  if (constraint && !constraint->isConditionallySatisfiable()) {
     // FIXME: diagnoseExplicitUnavailability should take an unmet requirement
     if (diagnoseExplicitUnavailability(D, R, Where, call, Flags))
       return true;
@@ -4121,10 +4121,10 @@ bool swift::diagnoseDeclAvailability(const ValueDecl *D, SourceRange R,
         && isa<ProtocolDecl>(D))
     return false;
 
-  if (!unmetRequirement)
+  if (!constraint)
     return false;
 
-  auto requiredRange = unmetRequirement->getRequiredNewerAvailabilityRange(ctx);
+  auto requiredRange = constraint->getRequiredNewerAvailabilityRange(ctx);
 
   // Diagnose (and possibly signal) for potential unavailability
   if (!requiredRange)
@@ -4601,9 +4601,9 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
       return true;
     }
 
-    auto unmetRequirement = getUnmetDeclAvailabilityRequirement(
+    auto constraint = getUnsatisfiedAvailabilityConstraint(
         ext, where.getDeclContext(), where.getAvailability());
-    if (unmetRequirement) {
+    if (constraint) {
       // FIXME: diagnoseExplicitUnavailability() should take unmet requirement
       if (diagnoseExplicitUnavailability(
               loc, rootConf, ext, where,
@@ -4614,7 +4614,7 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
 
       // Diagnose (and possibly signal) for potential unavailability
       if (auto requiredRange =
-              unmetRequirement->getRequiredNewerAvailabilityRange(ctx)) {
+              constraint->getRequiredNewerAvailabilityRange(ctx)) {
         if (diagnosePotentialUnavailability(rootConf, ext, loc, DC,
                                             *requiredRange)) {
           maybeEmitAssociatedTypeNote();

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"
@@ -245,18 +246,18 @@ void diagnoseOverrideOfUnavailableDecl(ValueDecl *override,
 
 /// Checks whether a declaration should be considered unavailable when referred
 /// to in the given declaration context and availability context and, if so,
-/// returns a result that describes the unmet availability requirements.
+/// returns a result that describes the unsatisfied constraint.
 /// Returns `std::nullopt` if the declaration is available.
-std::optional<UnmetAvailabilityRequirement>
-getUnmetDeclAvailabilityRequirement(const Decl *decl,
-                                    const DeclContext *declContext,
-                                    AvailabilityContext availabilityContext);
+std::optional<AvailabilityConstraint>
+getUnsatisfiedAvailabilityConstraint(const Decl *decl,
+                                     const DeclContext *declContext,
+                                     AvailabilityContext availabilityContext);
 
 /// Checks whether a declaration should be considered unavailable when referred
 /// to at the given source location in the given decl context and, if so,
-/// returns a result that describes the unmet availability requirements.
+/// returns a result that describes the unsatisfied constraint.
 /// Returns `std::nullopt` if the declaration is available.
-std::optional<UnmetAvailabilityRequirement> getUnmetDeclAvailabilityRequirement(
+std::optional<AvailabilityConstraint> getUnsatisfiedAvailabilityConstraint(
     const Decl *decl, const DeclContext *referenceDC, SourceLoc referenceLoc);
 
 /// Diagnose uses of the runtime support of the given type, such as

lib/Sema/TypeCheckPattern.cpp

@@ -38,10 +38,10 @@ using namespace swift;
 /// be kept in sync with importEnumCaseAlias in the ClangImporter library.
 static EnumElementDecl *extractEnumElement(DeclContext *DC, SourceLoc UseLoc,
                                            const VarDecl *constant) {
-  if (auto requirement =
-          getUnmetDeclAvailabilityRequirement(constant, DC, UseLoc)) {
+  if (auto constraint =
+          getUnsatisfiedAvailabilityConstraint(constant, DC, UseLoc)) {
     // Only diagnose explicit unavailability.
-    if (!requirement->isConditionallySatisfiable())
+    if (!constraint->isConditionallySatisfiable())
       diagnoseDeclAvailability(constant, UseLoc, nullptr,
                                ExportContext::forFunctionBody(DC, UseLoc));
   }