Merge pull request swiftlang#83580 from tshortli/refactor-opaque-type-availability

tshortli · web-flow · commit 02477604b10c · 2025-08-07T01:59:21.000-07:00
AST: Refactor `ConditionallyAvailableSubstitutions` to use `AvailabilityQuery`
diff --git a/include/swift/AST/AvailabilityQuery.h b/include/swift/AST/AvailabilityQuery.h
@@ -46,31 +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 value) {
+    return AvailabilityQuery(AvailabilityDomain::forUniversal(),
+                             value ? ResultKind::ConstTrue
+                                   : ResultKind::ConstFalse,
+                             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.
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -19,6 +19,7 @@
 
 #include "swift/AST/AccessScope.h"
 #include "swift/AST/Attr.h"
+#include "swift/AST/AvailabilityQuery.h"
 #include "swift/AST/AvailabilityRange.h"
 #include "swift/AST/CaptureInfo.h"
 #include "swift/AST/ClangNode.h"
@@ -3697,40 +3698,37 @@ class OpaqueTypeDecl final :
     return false;
   }
 
-  using AvailabilityCondition = std::pair<VersionRange, bool>;
-
   class ConditionallyAvailableSubstitutions final
-      : private llvm::TrailingObjects<
-            ConditionallyAvailableSubstitutions,
-            AvailabilityCondition> {
+      : private llvm::TrailingObjects<ConditionallyAvailableSubstitutions,
+                                      AvailabilityQuery> {
     friend TrailingObjects;
 
-    unsigned NumAvailabilityConditions;
+    unsigned NumAvailabilityQueries;
 
     SubstitutionMap Substitutions;
 
     /// A type with limited availability described by the provided set
     /// of availability conditions (with `and` relationship).
     ConditionallyAvailableSubstitutions(
-        ArrayRef<AvailabilityCondition> availabilityContext,
+        ArrayRef<AvailabilityQuery> availabilityQueries,
         SubstitutionMap substitutions)
-        : NumAvailabilityConditions(availabilityContext.size()),
+        : NumAvailabilityQueries(availabilityQueries.size()),
           Substitutions(substitutions) {
-      assert(!availabilityContext.empty());
-      std::uninitialized_copy(availabilityContext.begin(),
-                              availabilityContext.end(),
-                              getTrailingObjects<AvailabilityCondition>());
+      assert(!availabilityQueries.empty());
+      std::uninitialized_copy(availabilityQueries.begin(),
+                              availabilityQueries.end(),
+                              getTrailingObjects<AvailabilityQuery>());
     }
 
   public:
-    ArrayRef<AvailabilityCondition> getAvailability() const {
-      return {getTrailingObjects<AvailabilityCondition>(), NumAvailabilityConditions};
+    ArrayRef<AvailabilityQuery> getAvailabilityQueries() const {
+      return {getTrailingObjects<AvailabilityQuery>(), NumAvailabilityQueries};
     }
 
     SubstitutionMap getSubstitutions() const { return Substitutions; }
 
     static ConditionallyAvailableSubstitutions *
-    get(ASTContext &ctx, ArrayRef<AvailabilityCondition> availabilityContext,
+    get(ASTContext &ctx, ArrayRef<AvailabilityQuery> availabilityContext,
         SubstitutionMap substitutions);
   };
 };
diff --git a/lib/AST/AvailabilityScopeBuilder.cpp b/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.
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -10881,14 +10881,12 @@ void OpaqueTypeDecl::setConditionallyAvailableSubstitutions(
 
 OpaqueTypeDecl::ConditionallyAvailableSubstitutions *
 OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
-    ASTContext &ctx,
-    ArrayRef<AvailabilityCondition> availabilityContext,
+    ASTContext &ctx, ArrayRef<AvailabilityQuery> availabilityQueries,
     SubstitutionMap substitutions) {
-  auto size =
-      totalSizeToAlloc<AvailabilityCondition>(availabilityContext.size());
+  auto size = totalSizeToAlloc<AvailabilityQuery>(availabilityQueries.size());
   auto mem = ctx.Allocate(size, alignof(ConditionallyAvailableSubstitutions));
   return new (mem)
-      ConditionallyAvailableSubstitutions(availabilityContext, substitutions);
+      ConditionallyAvailableSubstitutions(availabilityQueries, substitutions);
 }
 
 bool AbstractFunctionDecl::hasInlinableBodyText() const {
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -2704,30 +2704,30 @@ namespace {
 
             // Emit a #available condition check, if it's `false` -
             // jump to the next conditionally available type.
-            auto conditions = underlyingTy->getAvailability();
+            auto queries = underlyingTy->getAvailabilityQueries();
 
             SmallVector<llvm::BasicBlock *, 4> conditionBlocks;
-            for (unsigned condIndex : indices(conditions)) {
+            for (unsigned queryIndex : indices(queries)) {
               // cond-<type_idx>-<cond_index>
               conditionBlocks.push_back(IGF.createBasicBlock(
-                  "cond-" + llvm::utostr(i) + "-" + llvm::utostr(condIndex)));
+                  "cond-" + llvm::utostr(i) + "-" + llvm::utostr(queryIndex)));
             }
 
             // Jump to the first condition.
             IGF.Builder.CreateBr(conditionBlocks.front());
 
-            for (unsigned condIndex : indices(conditions)) {
-              const auto &condition = conditions[condIndex];
+            for (unsigned queryIndex : indices(queries)) {
+              const auto &query = queries[queryIndex];
 
-              assert(condition.first.hasLowerEndpoint());
+              assert(query.getPrimaryArgument());
 
-              bool isUnavailability = condition.second;
-              auto version = condition.first.getLowerEndpoint();
+              bool isUnavailability = query.isUnavailability();
+              auto version = query.getPrimaryArgument().value();
               auto *major = getInt32Constant(version.getMajor());
               auto *minor = getInt32Constant(version.getMinor());
               auto *patch = getInt32Constant(version.getSubminor());
 
-              IGF.Builder.emitBlock(conditionBlocks[condIndex]);
+              IGF.Builder.emitBlock(conditionBlocks[queryIndex]);
 
               auto isAtLeast =
                   IGF.emitTargetOSVersionAtLeastCall(major, minor, patch);
@@ -2742,9 +2742,9 @@ namespace {
                     IGF.Builder.CreateXor(success, IGF.Builder.getIntN(1, -1));
               }
 
-              auto nextCondOrRet = condIndex == conditions.size() - 1
+              auto nextCondOrRet = queryIndex == queries.size() - 1
                                        ? returnTypeBB
-                                       : conditionBlocks[condIndex + 1];
+                                       : conditionBlocks[queryIndex + 1];
 
               IGF.Builder.CreateCondBr(success, nextCondOrRet,
                                        conditionalTypes[i + 1]);
@@ -2761,8 +2761,8 @@ namespace {
           IGF.Builder.emitBlock(conditionalTypes.back());
           auto universal = substitutionSet.back();
 
-          assert(universal->getAvailability().size() == 1 &&
-                 universal->getAvailability()[0].first.isAll());
+          assert(universal->getAvailabilityQueries().size() == 1 &&
+                 universal->getAvailabilityQueries()[0].isConstant());
 
           IGF.Builder.CreateRet(
               getResultValue(IGF, genericEnv, universal->getSubstitutions()));
diff --git a/lib/SILGen/SILGenAvailability.cpp b/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;
 }
diff --git a/lib/Sema/DerivedConformance/DerivedConformanceRawRepresentable.cpp b/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());
diff --git a/lib/Sema/MiscDiagnostics.cpp b/lib/Sema/MiscDiagnostics.cpp
@@ -3721,8 +3721,6 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
   // There is no clear winner here since there are candidates within
   // limited availability contexts.
   void finalizeOpaque(const Candidate &universallyAvailable) {
-    using AvailabilityCondition = OpaqueTypeDecl::AvailabilityCondition;
-
     SmallVector<OpaqueTypeDecl::ConditionallyAvailableSubstitutions *, 4>
         conditionalSubstitutions;
     SubstitutionMap universalSubstMap = std::get<1>(universallyAvailable);
@@ -3735,7 +3733,7 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
         continue;
 
       unsigned neverAvailableCount = 0, alwaysAvailableCount = 0;
-      SmallVector<AvailabilityCondition, 4> conditions;
+      SmallVector<AvailabilityQuery, 4> queries;
 
       for (const auto &elt : stmt->getCond()) {
         auto availabilityQuery = elt.getAvailability()->getAvailabilityQuery();
@@ -3762,11 +3760,7 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
         auto domain = availabilityQuery->getDomain();
         ASSERT(domain.isPlatform());
 
-        auto availabilityRange = availabilityQuery->getPrimaryRange();
-        ASSERT(availabilityRange);
-
-        conditions.push_back({availabilityRange->getRawVersionRange(),
-                              availabilityQuery->isUnavailability()});
+        queries.push_back(*availabilityQuery);
       }
 
       // If there were any conditions that were always false, then this
@@ -3782,18 +3776,18 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
         break;
       }
 
-      ASSERT(conditions.size() > 0);
+      ASSERT(queries.size() > 0);
 
       conditionalSubstitutions.push_back(
           OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
-              Ctx, conditions,
+              Ctx, queries,
               std::get<1>(candidate).mapReplacementTypesOutOfContext()));
     }
 
     // Add universally available choice as the last one.
     conditionalSubstitutions.push_back(
         OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
-            Ctx, {{VersionRange::all(), /*unavailable=*/false}},
+            Ctx, {AvailabilityQuery::universallyConstant(true)},
             universalSubstMap.mapReplacementTypesOutOfContext()));
 
     OpaqueDecl->setConditionallyAvailableSubstitutions(
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp

Original file line number	Diff line number	Diff line change
`@@ -131,14 +131,13 @@ getAvailabilityQueryForBackDeployment(AbstractFunctionDecl *AFD) {`
`131`	`131`	`variantRange = variantAttrAndRange->second;`
`132`	`132`
`133`	`133`	`return AvailabilityQuery::dynamic(attr->getAvailabilityDomain(),`
`134`		`- /isUnavailable=/false, primaryRange,`
`135`		`- variantRange);`
	`134`	`+ primaryRange, variantRange);`
`136`	`135`	`}`
`137`	`136`
`138`	`137`	`if (auto primaryAttrAndRange = AFD->getBackDeployedAttrAndRange(ctx))`
`139`	`138`	`return AvailabilityQuery::dynamic(`
`140`	`139`	`primaryAttrAndRange->first->getAvailabilityDomain(),`
`141`		`- /isUnavailable=/false, primaryAttrAndRange->second, std::nullopt);`
	`140`	`+ primaryAttrAndRange->second, std::nullopt);`
`142`	`141`
`143`	`142`	`return std::nullopt;`
`144`	`143`	`}`