SILGen: Fix if #unavailable mis-compile for zippered libraries.

Inverted availability queries were mis-compiled for zippered libraries because
the code that emits calls to `isOSVersionAtLeastOrVariantVersionAtLeast()` was
not updated when the `if #unavailable` syntax was introduced (at that time
support for zippered libraries had not yet been upstreamed). The result of
these calls is now inverted when appropriate.

To make it easier to manage the growing complexity of supporting availability
queries, Sema now models the relevant information about an availability query
with the new `AvailabilityQuery` type. It encapsulates the domain for the
query, the result if it is known at compile time, and the version tuple
arguments to pass to a runtime invocation if applicable.

Resolves rdar://147929876.

Author: tshortli

include/swift/AST/AvailabilityQuery.h

@@ -0,0 +1,128 @@
+//===--- AvailabilityQuery.h - Swift Availability Query ASTs ----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 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 availability query AST classes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_AVAILABILITY_QUERY_H
+#define SWIFT_AST_AVAILABILITY_QUERY_H
+
+#include "swift/AST/AvailabilityDomain.h"
+#include "swift/AST/AvailabilityRange.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/VersionTuple.h"
+
+namespace swift {
+/// Represents the information needed to evaluate an `#if available` query
+/// (either at runtime or compile-time).
+class AvailabilityQuery final {
+  AvailabilityDomain domain;
+  std::optional<AvailabilityRange> primaryRange;
+  std::optional<AvailabilityRange> variantRange;
+
+  enum class ResultKind : uint8_t {
+    /// The result of the query is true at compile-time.
+    ConstTrue = 0,
+    /// The result of the query is false at compile-time.
+    ConstFalse = 1,
+    /// The result of the query must be determined at runtime.
+    Dynamic = 2,
+  };
+  ResultKind kind;
+
+  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) {};
+
+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) {
+    return AvailabilityQuery(
+        domain, value ? ResultKind::ConstTrue : ResultKind::ConstFalse,
+        isUnavailable, 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,
+          const std::optional<AvailabilityRange> &primaryRange,
+          const std::optional<AvailabilityRange> &variantRange) {
+    return AvailabilityQuery(domain, ResultKind::Dynamic, isUnavailable,
+                             primaryRange, variantRange);
+  }
+
+  /// Returns the domain that the query applies to.
+  AvailabilityDomain getDomain() const { return domain; }
+
+  /// Returns true if the query's result is determined at compile-time.
+  bool isConstant() const { return kind != ResultKind::Dynamic; }
+
+  /// Returns true if the query was spelled `#unavailable`.
+  bool isUnavailability() const { return unavailable; }
+
+  /// Returns the boolean result of the query if it is known at compile-time, or
+  /// `std::nullopt` otherwise. The returned value accounts for whether the
+  /// query was spelled `#unavailable`.
+  std::optional<bool> getConstantResult() const {
+    switch (kind) {
+    case ResultKind::ConstTrue:
+      return !unavailable;
+    case ResultKind::ConstFalse:
+      return unavailable;
+    case ResultKind::Dynamic:
+      return std::nullopt;
+    }
+  }
+
+  /// Returns the availability range that is the first argument to query
+  /// function.
+  std::optional<AvailabilityRange> getPrimaryRange() const {
+    return primaryRange;
+  }
+
+  /// Returns the version tuple that is the first argument to query function.
+  std::optional<llvm::VersionTuple> getPrimaryArgument() const {
+    if (!primaryRange)
+      return std::nullopt;
+    return primaryRange->getRawMinimumVersion();
+  }
+
+  /// Returns the availability range that is the second argument to query
+  /// function. This represents the `-target-variant` version when compiling a
+  /// zippered library.
+  std::optional<AvailabilityRange> getVariantRange() const {
+    return variantRange;
+  }
+
+  /// Returns the version tuple that is the second argument to query function.
+  /// This represents the `-target-variant` version when compiling a zippered
+  /// library.
+  std::optional<llvm::VersionTuple> getVariantArgument() const {
+    if (!variantRange)
+      return std::nullopt;
+    return variantRange->getRawMinimumVersion();
+  }
+};
+
+} // end namespace swift
+
+#endif

include/swift/AST/AvailabilitySpec.h

@@ -1,4 +1,4 @@
-//===--- AvailabilitySpec.h - Swift Availability Query ASTs -----*- C++ -*-===//
+//===--- AvailabilitySpec.h - Swift Availability Spec ASTs ------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //

include/swift/AST/Stmt.h

@@ -19,6 +19,7 @@
 
 #include "swift/AST/ASTAllocated.h"
 #include "swift/AST/ASTNode.h"
+#include "swift/AST/AvailabilityQuery.h"
 #include "swift/AST/AvailabilityRange.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/IfConfigClause.h"
@@ -477,20 +478,11 @@ class alignas(8) PoundAvailableInfo final :
   SourceLoc LParenLoc;
   SourceLoc RParenLoc;
 
-  // The number of queries tail allocated after this object.
+  /// The number of queries tail allocated after this object.
   unsigned NumQueries;
-  
-  /// The version range when this query will return true. This value is
-  /// filled in by Sema.
-  std::optional<VersionRange> AvailableRange;
-
-  /// For zippered builds, this is the version range for the target variant
-  /// that must hold for the query to return true. For example, when
-  /// compiling with target x86_64-macosx10.15 and target-variant
-  /// x86_64-ios13.0 a query of #available(macOS 10.22, iOS 20.0, *) will
-  /// have a variant range of [20.0, +inf).
-  /// This is filled in by Sema.
-  std::optional<VersionRange> VariantAvailableRange;
+
+  /// The type-checked availability query information.
+  std::optional<const AvailabilityQuery> Query;
 
   struct {
     unsigned isInvalid : 1;
@@ -504,8 +496,7 @@ class alignas(8) PoundAvailableInfo final :
                      ArrayRef<AvailabilitySpec *> queries, SourceLoc RParenLoc,
                      bool isUnavailability)
       : PoundLoc(PoundLoc), LParenLoc(LParenLoc), RParenLoc(RParenLoc),
-        NumQueries(queries.size()), AvailableRange(VersionRange::empty()),
-        VariantAvailableRange(VersionRange::empty()), Flags() {
+        NumQueries(queries.size()), Flags() {
     Flags.isInvalid = false;
     Flags.isUnavailability = isUnavailability;
     std::uninitialized_copy(queries.begin(), queries.end(),
@@ -539,16 +530,11 @@ class alignas(8) PoundAvailableInfo final :
   SourceRange getSourceRange() const { return SourceRange(getStartLoc(),
                                                           getEndLoc()); }
 
-  std::optional<VersionRange> getAvailableRange() const {
-    return AvailableRange;
-  }
-  void setAvailableRange(const VersionRange &Range) { AvailableRange = Range; }
-
-  std::optional<VersionRange> getVariantAvailableRange() const {
-    return VariantAvailableRange;
+  std::optional<const AvailabilityQuery> getAvailabilityQuery() const {
+    return Query;
   }
-  void setVariantAvailableRange(const VersionRange &Range) {
-    VariantAvailableRange = Range;
+  void setAvailabilityQuery(const AvailabilityQuery &query) {
+    Query.emplace(query);
   }
 
   bool isUnavailability() const { return Flags.isUnavailability; }

lib/AST/AvailabilityScopeBuilder.cpp

@@ -824,6 +824,77 @@ class AvailabilityScopeBuilder : private ASTWalker {
     pushContext(fallthroughScope, parentBrace);
   }
 
+  AvailabilityQuery buildAvailabilityQuery(
+      const SemanticAvailabilitySpec spec,
+      const std::optional<SemanticAvailabilitySpec> &variantSpec,
+      bool isUnavailability) {
+    auto domain = spec.getDomain();
+
+    // Variant availability specfications are only supported for platform
+    // domains when compiling with a -target-variant.
+    if (!Context.LangOpts.TargetVariant)
+      ASSERT(!variantSpec);
+
+    auto runtimeRangeForSpec =
+        [](const std::optional<SemanticAvailabilitySpec> &spec)
+        -> std::optional<AvailabilityRange> {
+      if (!spec || spec->isWildcard() || !spec->getDomain().isVersioned())
+        return std::nullopt;
+
+      return AvailabilityRange(spec->getRuntimeVersion());
+    };
+
+    auto primaryRange = runtimeRangeForSpec(spec);
+    auto variantRange = runtimeRangeForSpec(variantSpec);
+
+    switch (domain.getKind()) {
+    case AvailabilityDomain::Kind::Embedded:
+    case AvailabilityDomain::Kind::SwiftLanguage:
+    case AvailabilityDomain::Kind::PackageDescription:
+      // These domains don't support queries.
+      llvm::report_fatal_error("unsupported domain");
+
+    case AvailabilityDomain::Kind::Universal:
+      DEBUG_ASSERT(spec.isWildcard());
+
+      // 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);
+
+      // 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,
+                                        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);
+    case AvailabilityDomain::Kind::Custom:
+      auto customDomain = domain.getCustomDomain();
+      ASSERT(customDomain);
+
+      switch (customDomain->getKind()) {
+      case CustomAvailabilityDomain::Kind::Enabled:
+        return AvailabilityQuery::constant(domain, isUnavailability, true);
+      case CustomAvailabilityDomain::Kind::Disabled:
+        return AvailabilityQuery::constant(domain, isUnavailability, false);
+      case CustomAvailabilityDomain::Kind::Dynamic:
+        return AvailabilityQuery::dynamic(domain, isUnavailability,
+                                          primaryRange, variantRange);
+      }
+    }
+  }
+
   /// Build the availability scopes for a StmtCondition and return a pair of
   /// optional availability contexts, the first for the true branch and the
   /// second for the false branch. A value of `nullopt` for a given branch
@@ -982,23 +1053,18 @@ class AvailabilityScopeBuilder : private ASTWalker {
         continue;
       }
 
-      auto runtimeQueryRange = runtimeQueryRangeForSpec(*spec);
-      query->setAvailableRange(runtimeQueryRange.getRawVersionRange());
-
       // When compiling zippered for macCatalyst, we need to collect both
       // a macOS version (the target version) and an iOS/macCatalyst version
       // (the target-variant). These versions will both be passed to a runtime
       // entrypoint that will check either the macOS version or the iOS
       // version depending on the kind of process this code is loaded into.
-      if (Context.LangOpts.TargetVariant) {
-        auto variantSpec =
-            bestActiveSpecForQuery(query, /*ForTargetVariant*/ true);
-        if (variantSpec) {
-          auto variantQueryRange = runtimeQueryRangeForSpec(*variantSpec);
-          query->setVariantAvailableRange(
-              variantQueryRange.getRawVersionRange());
-        }
-      }
+      std::optional<SemanticAvailabilitySpec> variantSpec =
+          (Context.LangOpts.TargetVariant)
+              ? bestActiveSpecForQuery(query, /*ForTargetVariant*/ true)
+              : std::nullopt;
+
+      query->setAvailabilityQuery(buildAvailabilityQuery(
+          *spec, variantSpec, query->isUnavailability()));
 
       // Wildcards are expected to be "useless". There may be other specs in
       // this query that are useful when compiling for other platforms.
@@ -1164,24 +1230,6 @@ class AvailabilityScopeBuilder : private ASTWalker {
     }
   }
 
-  /// Return the availability context for the given spec.
-  AvailabilityRange runtimeQueryRangeForSpec(SemanticAvailabilitySpec spec) {
-    if (spec.isWildcard())
-      return AvailabilityRange::alwaysAvailable();
-
-    auto domain = spec.getDomain();
-    if (domain.isVersioned())
-      return AvailabilityRange(spec.getRuntimeVersion());
-
-    // If it's not a versioned domain, we must be querying whether a domain is
-    // present or absent.
-    if (domain.isCustom() && domain.getCustomDomain()->getKind() ==
-                                 CustomAvailabilityDomain::Kind::Disabled)
-      return AvailabilityRange::neverAvailable();
-
-    return AvailabilityRange::alwaysAvailable();
-  }
-
   /// For the given spec, returns a pair of availability ranges. The first range
   /// is for the if/then flow and the second is for the if/else flow.
   std::pair<std::optional<AvailabilityRange>, std::optional<AvailabilityRange>>