Merge pull request #82671 from tshortli/zippered-miscompile-if-unavailable

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

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/DiagnosticsSema.def

@@ -5300,7 +5300,9 @@ GROUPED_ERROR(opaque_type_var_no_init,OpaqueTypeInference,none,
 GROUPED_ERROR(opaque_type_var_no_underlying_type,OpaqueTypeInference,none,
       "property declares an opaque return type, but cannot infer the "
       "underlying type from its initializer expression", ())
-
+GROUPED_ERROR(opaque_type_unsupported_availability,OpaqueTypeInference,none,
+      "opaque return type cannot depend on %0 availability",
+      (AvailabilityDomain))
 
 //------------------------------------------------------------------------------
 // MARK: Discard Statement

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>>