Sema: Rename getUnmetDeclAvailabilityRequirement().

Name it `getUnsatisfiedAvailabilityConstraint()` to match
`AvailabilityConstraint`.

Author: tshortli

lib/Sema/BuilderTransform.cpp

@@ -1322,7 +1322,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

@@ -3033,7 +3033,7 @@ bool diagnoseExplicitUnavailability(
 }
 
 std::optional<AvailabilityConstraint>
-swift::getUnmetDeclAvailabilityRequirement(
+swift::getUnsatisfiedAvailabilityConstraint(
     const Decl *decl, const DeclContext *declContext,
     AvailabilityContext availabilityContext) {
   auto &ctx = declContext->getASTContext();
@@ -3075,10 +3075,10 @@ swift::getUnmetDeclAvailabilityRequirement(
 }
 
 std::optional<AvailabilityConstraint>
-swift::getUnmetDeclAvailabilityRequirement(const Decl *decl,
-                                           const DeclContext *referenceDC,
-                                           SourceLoc referenceLoc) {
-  return getUnmetDeclAvailabilityRequirement(
+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

@@ -246,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<AvailabilityConstraint>
-getUnmetDeclAvailabilityRequirement(const Decl *decl,
-                                    const DeclContext *declContext,
-                                    AvailabilityContext availabilityContext);
+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<AvailabilityConstraint> 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));
   }