AST: Refactor AvailabilityQuery constructors.

Get rid of the boolean arguments for unavailability in AvailabilityQuery's
constructors and introduce a `asUnavailable()` modifier that can be used
instead in the contexts where unavailability is relevant.

Author: tshortli

include/swift/AST/AvailabilityQuery.h

@@ -46,40 +46,50 @@ class AvailabilityQuery final {
   bool unavailable;
 
   AvailabilityQuery(AvailabilityDomain domain, ResultKind kind,
-                    bool isUnavailable,
                     const std::optional<AvailabilityRange> &primaryRange,
                     const std::optional<AvailabilityRange> &variantRange)
       : domain(domain), primaryRange(primaryRange), variantRange(variantRange),
-        kind(kind), unavailable(isUnavailable) {};
+        kind(kind), unavailable(false) {};
 
 public:
   /// Returns an `AvailabilityQuery` for a query that evaluates to true or
   /// false at compile-time.
-  static AvailabilityQuery constant(AvailabilityDomain domain,
-                                    bool isUnavailable, bool value) {
+  static AvailabilityQuery constant(AvailabilityDomain domain, bool value) {
     return AvailabilityQuery(
         domain, value ? ResultKind::ConstTrue : ResultKind::ConstFalse,
-        isUnavailable, std::nullopt, std::nullopt);
+        std::nullopt, std::nullopt);
   }
 
   /// Returns an `AvailabilityQuery` for a query that evaluates to true or
   /// false at compile-time in the universal availability domain.
-  static AvailabilityQuery universallyConstant(bool isUnavailable, bool value) {
+  static AvailabilityQuery universallyConstant(bool value) {
     return AvailabilityQuery(AvailabilityDomain::forUniversal(),
                              value ? ResultKind::ConstTrue
                                    : ResultKind::ConstFalse,
-                             isUnavailable, std::nullopt, std::nullopt);
+                             std::nullopt, std::nullopt);
   }
 
   /// Returns an `AvailabilityQuery` for a query that must be evaluated at
   /// runtime with the given arguments, which may be zero, one, or two version
   /// tuples that should be passed to the query function.
   static AvailabilityQuery
-  dynamic(AvailabilityDomain domain, bool isUnavailable,
+  dynamic(AvailabilityDomain domain,
           const std::optional<AvailabilityRange> &primaryRange,
           const std::optional<AvailabilityRange> &variantRange) {
-    return AvailabilityQuery(domain, ResultKind::Dynamic, isUnavailable,
-                             primaryRange, variantRange);
+    return AvailabilityQuery(domain, ResultKind::Dynamic, primaryRange,
+                             variantRange);
+  }
+
+  /// Returns a copy of the `AvailabilityQuery` that has been modified to
+  /// represent an `if #unavailable` query if `isUnavailability` is true, or an
+  /// `if #available` query otherwise.
+  AvailabilityQuery asUnavailable(bool isUnavailability) const {
+    if (isUnavailability != unavailable) {
+      AvailabilityQuery copy = *this;
+      copy.unavailable = isUnavailability;
+      return copy;
+    }
+    return *this;
   }
 
   /// Returns the domain that the query applies to.

lib/AST/AvailabilityScopeBuilder.cpp

@@ -816,8 +816,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
 
   AvailabilityQuery buildAvailabilityQuery(
       const SemanticAvailabilitySpec spec,
-      const std::optional<SemanticAvailabilitySpec> &variantSpec,
-      bool isUnavailability) {
+      const std::optional<SemanticAvailabilitySpec> &variantSpec) {
     auto domain = spec.getDomain();
 
     // Variant availability specfications are only supported for platform
@@ -850,37 +849,34 @@ class AvailabilityScopeBuilder : private ASTWalker {
       // If all of the specs that matched are '*', then the query trivially
       // evaluates to "true" at compile time.
       if (!variantRange)
-        return AvailabilityQuery::constant(domain, isUnavailability, true);
+        return AvailabilityQuery::constant(domain, true);
 
       // Otherwise, generate a dynamic query for the variant spec. For example,
       // when compiling zippered for macOS, this should generate a query that
       // just checks the iOS version at runtime:
       //
       //    if #available(iOS 18, *) { ... }
       //
-      return AvailabilityQuery::dynamic(variantSpec->getDomain(),
-                                        isUnavailability, primaryRange,
+      return AvailabilityQuery::dynamic(variantSpec->getDomain(), primaryRange,
                                         variantRange);
 
     case AvailabilityDomain::Kind::Platform:
       // Platform checks are always dynamic. The SIL optimizer is responsible
       // eliminating these checks when it can prove that they can never fail
       // (due to the deployment target). We can't perform that analysis here
       // because it may depend on inlining.
-      return AvailabilityQuery::dynamic(domain, isUnavailability, primaryRange,
-                                        variantRange);
+      return AvailabilityQuery::dynamic(domain, primaryRange, variantRange);
     case AvailabilityDomain::Kind::Custom:
       auto customDomain = domain.getCustomDomain();
       ASSERT(customDomain);
 
       switch (customDomain->getKind()) {
       case CustomAvailabilityDomain::Kind::Enabled:
-        return AvailabilityQuery::constant(domain, isUnavailability, true);
+        return AvailabilityQuery::constant(domain, true);
       case CustomAvailabilityDomain::Kind::Disabled:
-        return AvailabilityQuery::constant(domain, isUnavailability, false);
+        return AvailabilityQuery::constant(domain, false);
       case CustomAvailabilityDomain::Kind::Dynamic:
-        return AvailabilityQuery::dynamic(domain, isUnavailability,
-                                          primaryRange, variantRange);
+        return AvailabilityQuery::dynamic(domain, primaryRange, variantRange);
       }
     }
   }
@@ -1053,8 +1049,9 @@ class AvailabilityScopeBuilder : private ASTWalker {
               ? bestActiveSpecForQuery(query, /*ForTargetVariant*/ true)
               : std::nullopt;
 
-      query->setAvailabilityQuery(buildAvailabilityQuery(
-          *spec, variantSpec, query->isUnavailability()));
+      query->setAvailabilityQuery(
+          buildAvailabilityQuery(*spec, variantSpec)
+              .asUnavailable(query->isUnavailability()));
 
       // Wildcards are expected to be "useless". There may be other specs in
       // this query that are useful when compiling for other platforms.

lib/SILGen/SILGenAvailability.cpp

@@ -131,14 +131,13 @@ getAvailabilityQueryForBackDeployment(AbstractFunctionDecl *AFD) {
       variantRange = variantAttrAndRange->second;
 
     return AvailabilityQuery::dynamic(attr->getAvailabilityDomain(),
-                                      /*isUnavailable=*/false, primaryRange,
-                                      variantRange);
+                                      primaryRange, variantRange);
   }
 
   if (auto primaryAttrAndRange = AFD->getBackDeployedAttrAndRange(ctx))
     return AvailabilityQuery::dynamic(
         primaryAttrAndRange->first->getAvailabilityDomain(),
-        /*isUnavailable=*/false, primaryAttrAndRange->second, std::nullopt);
+        primaryAttrAndRange->second, std::nullopt);
 
   return std::nullopt;
 }

lib/Sema/DerivedConformance/DerivedConformanceRawRepresentable.cpp

@@ -218,8 +218,7 @@ struct RuntimeVersionCheck {
     // This won't be filled in by TypeCheckAvailability because we have
     // invalid SourceLocs in this area of the AST.
     availableInfo->setAvailabilityQuery(AvailabilityQuery::dynamic(
-        domain, /*isUnavailable=*/false, AvailabilityRange(getVersionRange()),
-        std::nullopt));
+        domain, AvailabilityRange(getVersionRange()), std::nullopt));
 
     // earlyReturnBody = "{ return nil }"
     auto earlyReturn = new (C) FailStmt(SourceLoc(), SourceLoc());

lib/Sema/MiscDiagnostics.cpp

@@ -3787,9 +3787,7 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
     // Add universally available choice as the last one.
     conditionalSubstitutions.push_back(
         OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
-            Ctx,
-            {AvailabilityQuery::universallyConstant(/*isUnavailable=*/false,
-                                                    /*value=*/true)},
+            Ctx, {AvailabilityQuery::universallyConstant(true)},
             universalSubstMap.mapReplacementTypesOutOfContext()));
 
     OpaqueDecl->setConditionallyAvailableSubstitutions(

lib/Serialization/Deserialization.cpp

@@ -4592,7 +4592,8 @@ class DeclDeserializer {
       DECODE_VER_TUPLE(version);
 
       queries.push_back(AvailabilityQuery::dynamic(
-          domain, isUnavailability, AvailabilityRange(version), std::nullopt));
+                            domain, AvailabilityRange(version), std::nullopt)
+                            .asUnavailable(isUnavailability));
     }
   }
 
@@ -4731,7 +4732,7 @@ class DeclDeserializer {
               OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
                   ctx,
                   {AvailabilityQuery::universallyConstant(
-                      /*isUnavailable=*/false, /*value=*/true)},
+                      /*value=*/true)},
                   subMapOrError.get()));
 
           opaqueDecl->setConditionallyAvailableSubstitutions(limitedAvailability);