AST: Skip codegen for decls that are unavailable in custom domains.

tshortli · tshortli · commit 5e0eb09fc009 · 2025-03-17T22:46:07.000-07:00
Regardless of the value specified for `-unavailable-decl-optimization`, decls
that are unavailable in custom availability domains should be treated as always
unreachable at runtime.

Part of rdar://138441307.
diff --git a/include/swift/AST/AvailabilityDomain.h b/include/swift/AST/AvailabilityDomain.h
@@ -123,11 +123,6 @@ class AvailabilityDomain final {
                : std::nullopt;
   }
 
-  const CustomAvailabilityDomain *getCustomDomain() const {
-    ASSERT(isCustom());
-    return storage.get<const CustomAvailabilityDomain *>();
-  }
-
 public:
   AvailabilityDomain() {}
 
@@ -206,6 +201,14 @@ class AvailabilityDomain final {
     return PlatformKind::none;
   }
 
+  /// If the domain represents a user-defined domain, returns the metadata for
+  /// the domain. Returns `nullptr` otherwise.
+  const CustomAvailabilityDomain *getCustomDomain() const {
+    if (isCustom())
+      return storage.get<const CustomAvailabilityDomain *>();
+    return nullptr;
+  }
+
   /// Returns true if availability for this domain can be specified in terms of
   /// version ranges.
   bool isVersioned() const;
@@ -228,11 +231,11 @@ class AvailabilityDomain final {
   /// set of active platform-specific domains.
   bool isActiveForTargetPlatform(const ASTContext &ctx) const;
 
-  /// Returns the minimum available range for the attribute's domain. For
+  /// Returns the domain's minimum available range for type checking. For
   /// example, for the domain of the platform that compilation is targeting,
-  /// this will be the deployment target. For the Swift language domain, this
-  /// will be the language mode for compilation. For domains which have don't
-  /// have a "deployment target", this returns `std::nullopt`.
+  /// this version is specified with the `-target` option. For the Swift
+  /// language domain, it is specified with the `-swift-version` option. Returns
+  /// `std::nullopt` for domains which have don't have a "deployment target".
   std::optional<AvailabilityRange>
   getDeploymentRange(const ASTContext &ctx) const;
 
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -4153,6 +4153,10 @@ enum class DeclRuntimeAvailability : uint8_t {
   /// with strong references. To preserve ABI stability, the decl must still be
   /// emitted.
   AlwaysUnavailableABICompatible,
+
+  /// The decl is always unavailable and should never be reachable at runtime
+  /// nor be required at load time.
+  AlwaysUnavailable,
 };
 
 class DeclRuntimeAvailabilityRequest
diff --git a/lib/AST/Availability.cpp b/lib/AST/Availability.cpp
@@ -563,28 +563,43 @@ getRootTargetDomains(const ASTContext &ctx) {
 
 static bool constraintIndicatesRuntimeUnavailability(
     const AvailabilityConstraint &constraint, const ASTContext &ctx) {
+  std::optional<CustomAvailabilityDomain::Kind> customDomainKind;
+  if (auto customDomain = constraint.getDomain().getCustomDomain())
+    customDomainKind = customDomain->getKind();
+
   switch (constraint.getReason()) {
-  case AvailabilityConstraint::Reason::UnconditionallyUnavailable: {
+  case AvailabilityConstraint::Reason::UnconditionallyUnavailable:
+    if (customDomainKind)
+      return customDomainKind == CustomAvailabilityDomain::Kind::Enabled;
     return true;
-  }
-  case AvailabilityConstraint::Reason::UnavailableForDeployment:
   case AvailabilityConstraint::Reason::Obsoleted:
+  case AvailabilityConstraint::Reason::UnavailableForDeployment:
+    return false;
   case AvailabilityConstraint::Reason::PotentiallyUnavailable:
+    if (customDomainKind)
+      return customDomainKind == CustomAvailabilityDomain::Kind::Disabled;
     return false;
   }
 }
 
+/// Returns true if a decl that is unavailable in the given domain must still be
+/// emitted to preserve load time ABI compatibility.
+static bool
+domainRequiresABICompatibleUnavailableDecls(AvailabilityDomain domain,
+                                            const ASTContext &ctx) {
+  // FIXME: [availability] Restrict ABI compatible unavailable decls to modules
+  // compiled with macOS, iOS, watchOS, tvOS, or visionOS target triples. For
+  // other targets, unavailable code should always be stripped from binaries.
+  return domain.isUniversal() || domain.isPlatform();
+}
+
 /// Computes the `DeclRuntimeAvailability` value for `decl` in isolation.
 static DeclRuntimeAvailability
 computeDeclRuntimeAvailability(const Decl *decl) {
   // Don't trust unavailability on declarations from Clang modules.
   if (isa<ClangModuleUnit>(decl->getDeclContext()->getModuleScopeContext()))
     return DeclRuntimeAvailability::PotentiallyAvailable;
 
-  // Check whether the decl is unavailable at all.
-  if (!decl->isUnavailable())
-    return DeclRuntimeAvailability::PotentiallyAvailable;
-
   auto &ctx = decl->getASTContext();
   auto rootTargetDomains = getRootTargetDomains(ctx);
   auto remainingTargetDomains = rootTargetDomains;
@@ -595,41 +610,67 @@ computeDeclRuntimeAvailability(const Decl *decl) {
   // extension.
   flags |= AvailabilityConstraintFlag::SkipEnclosingExtension;
 
-  // FIXME: [availability] Inactive domains have to be included because iOS
-  // availability is considered inactive when compiling a zippered module.
+  // FIXME: [availability] Replace IncludeAllDomains with a RuntimeAvailability
+  // flag that includes the target variant constraints and keeps all constraints
+  // from active platforms.
   flags |= AvailabilityConstraintFlag::IncludeAllDomains;
 
   auto constraints = getAvailabilityConstraintsForDecl(
       decl, AvailabilityContext::forInliningTarget(ctx), flags);
 
+  // First, collect the unavailable domains from the constraints.
+  llvm::SmallVector<AvailabilityDomain, 8> unavailableDomains;
   for (auto constraint : constraints) {
-    if (!constraintIndicatesRuntimeUnavailability(constraint, ctx))
+    if (constraintIndicatesRuntimeUnavailability(constraint, ctx))
+      unavailableDomains.push_back(constraint.getDomain());
+  }
+
+  // Check whether there are any available attributes that would make the
+  // decl available in descendants of the unavailable domains.
+  for (auto attr :
+       decl->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto domain = attr.getDomain();
+    if (llvm::is_contained(unavailableDomains, domain))
       continue;
 
+    llvm::erase_if(unavailableDomains, [domain](auto unavailableDomain) {
+      return unavailableDomain.contains(domain);
+    });
+  }
+
+  // Check the remaining unavailable domains to see if the requirements for
+  // runtime unreachability are met.
+  auto result = DeclRuntimeAvailability::PotentiallyAvailable;
+  for (auto domain : unavailableDomains) {
     // Check whether the constraint is from a relevant domain.
-    auto domain = constraint.getDomain();
     bool isTargetDomain = rootTargetDomains.contains(domain);
-
     if (!domain.isActive(ctx) && !isTargetDomain)
       continue;
 
     if (!domain.isRoot())
       continue;
 
+    // We've found an unavailable target domain. If all the target domains are
+    // unavailable then the decl is unreachable at runtime.
     if (isTargetDomain) {
-      // If the decl is still potentially available in some compatibility
-      // domain, keep looking at the remaining constraints.
       remainingTargetDomains.remove(domain);
-      if (!remainingTargetDomains.empty())
-        continue;
+      if (remainingTargetDomains.empty())
+        result = DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
+
+      continue;
     }
 
-    // Either every compatibility domain has been proven unavailable or this
-    // constraint proves runtime unavailability on its own.
-    return DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
+    // We've found a single unavailable domain that alone proves the decl is
+    // unreachable at runtime. It may still be required at load time, though.
+    if (domainRequiresABICompatibleUnavailableDecls(domain, ctx)) {
+      result = DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
+      continue;
+    }
+
+    return DeclRuntimeAvailability::AlwaysUnavailable;
   }
 
-  return DeclRuntimeAvailability::PotentiallyAvailable;
+  return result;
 }
 
 /// Determines the `DeclRuntimeAvailability` value for `decl` via
@@ -651,8 +692,8 @@ DeclRuntimeAvailabilityRequest::evaluate(Evaluator &evaluator,
 
   // If the inherited runtime availability is already maximally unavailable
   // then skip computing unavailability for this declaration.
-  if (inherited == DeclRuntimeAvailability::AlwaysUnavailableABICompatible)
-    return DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
+  if (inherited == DeclRuntimeAvailability::AlwaysUnavailable)
+    return DeclRuntimeAvailability::AlwaysUnavailable;
 
   auto availability = computeDeclRuntimeAvailability(decl);
   return std::max(inherited, availability);
@@ -676,7 +717,7 @@ bool Decl::isAvailableDuringLowering() const {
 
   if (getEffectiveUnavailableDeclOptimization(getASTContext()) !=
       UnavailableDeclOptimization::Complete)
-    return true;
+    return availability < DeclRuntimeAvailability::AlwaysUnavailable;
 
   // All unreachable declarations should be skipped during lowering
   // when -unavailable-decl-optimization=complete is specified.
diff --git a/lib/Frontend/Frontend.cpp b/lib/Frontend/Frontend.cpp
@@ -1398,8 +1398,7 @@ static void configureAvailabilityDomains(const ASTContext &ctx,
   llvm::SmallDenseMap<Identifier, const CustomAvailabilityDomain *> domainMap;
   auto createAndInsertDomain = [&](const std::string &name,
                                    CustomAvailabilityDomain::Kind kind) {
-    auto *domain = CustomAvailabilityDomain::get(
-        name, mainModule, CustomAvailabilityDomain::Kind::Enabled, ctx);
+    auto *domain = CustomAvailabilityDomain::get(name, mainModule, kind, ctx);
     bool inserted = domainMap.insert({domain->getName(), domain}).second;
     ASSERT(inserted); // Domains must be unique.
   };
diff --git a/test/SILGen/unavailable_decl_custom_domain.swift b/test/SILGen/unavailable_decl_custom_domain.swift
@@ -0,0 +1,83 @@
+// RUN: %target-swift-emit-silgen -module-name Test %s -verify \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -define-enabled-availability-domain EnabledDomain \
+// RUN:   -define-disabled-availability-domain DisabledDomain \
+// RUN:   -define-dynamic-availability-domain DynamicDomain \
+// RUN:   | %FileCheck %s --check-prefixes=CHECK
+
+// RUN: %target-swift-emit-silgen -module-name Test %s -verify \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -define-enabled-availability-domain EnabledDomain \
+// RUN:   -define-disabled-availability-domain DisabledDomain \
+// RUN:   -define-dynamic-availability-domain DynamicDomain \
+// RUN:   -unavailable-decl-optimization=stub \
+// RUN:   | %FileCheck %s --check-prefixes=CHECK
+
+// RUN: %target-swift-emit-silgen -module-name Test %s -verify \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -define-enabled-availability-domain EnabledDomain \
+// RUN:   -define-disabled-availability-domain DisabledDomain \
+// RUN:   -define-dynamic-availability-domain DynamicDomain \
+// RUN:   -unavailable-decl-optimization=complete \
+// RUN:   | %FileCheck %s --check-prefixes=CHECK
+
+// REQUIRES: swift_feature_CustomAvailability
+
+// CHECK: s4Test24availableInEnabledDomainyyF
+@available(EnabledDomain)
+public func availableInEnabledDomain() { }
+
+// CHECK-NOT: s4Test26unavailableInEnabledDomainyyF
+@available(EnabledDomain, unavailable)
+public func unavailableInEnabledDomain() { }
+
+// CHECK-NOT: s4Test25availableInDisabledDomainyyF
+@available(DisabledDomain)
+public func availableInDisabledDomain() { }
+
+// CHECK: s4Test27unavailableInDisabledDomainyyF
+@available(DisabledDomain, unavailable)
+public func unavailableInDisabledDomain() { }
+
+// CHECK: s4Test24availableInDynamicDomainyyF
+@available(DynamicDomain)
+public func availableInDynamicDomain() { }
+
+// CHECK: s4Test26unavailableInDynamicDomainyyF
+@available(DynamicDomain, unavailable)
+public func unavailableInDynamicDomain() { }
+
+// CHECK: s4Test25deprecatedInEnabledDomainyyF
+@available(EnabledDomain, deprecated)
+public func deprecatedInEnabledDomain() { }
+
+// FIXME: [availability] This decl should be skipped.
+// CHECK: s4Test26deprecatedInDisabledDomainyyF
+@available(DisabledDomain, deprecated)
+public func deprecatedInDisabledDomain() { }
+
+// CHECK: s4Test25deprecatedInDynamicDomainyyF
+@available(DynamicDomain, deprecated)
+public func deprecatedInDynamicDomain() { }
+
+// CHECK: s4Test22renamedInEnabledDomainyyF
+@available(EnabledDomain, renamed: "availableInEnabledDomain")
+public func renamedInEnabledDomain() { }
+
+// CHECK-NOT: s4Test23renamedInDisabledDomainyyF
+@available(DisabledDomain, renamed: "availableInDisabledDomain")
+public func renamedInDisabledDomain() { }
+
+// CHECK: s4Test22renamedInDynamicDomainyyF
+@available(DynamicDomain, renamed: "availableInDynamicDomain")
+public func renamedInDynamicDomain() { }
+
+// CHECK-NOT: s4Test35availableInEnabledAndDisabledDomainyyF
+@available(EnabledDomain)
+@available(DisabledDomain)
+public func availableInEnabledAndDisabledDomain() { }
+
+// CHECK-NOT: s4Test35availableInDisabledAndEnabledDomainyyF
+@available(DisabledDomain)
+@available(EnabledDomain)
+public func availableInDisabledAndEnabledDomain() { }
diff --git a/test/SILGen/unavailable_decl_optimization_stub_maccatalyst.swift b/test/SILGen/unavailable_decl_optimization_stub_maccatalyst.swift
@@ -0,0 +1,93 @@
+// RUN: %target-swift-emit-silgen -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=stub -target %target-cpu-apple-ios13.1-macabi | %FileCheck %s --check-prefixes=CHECK,CHECK-NO-EXTENSION
+// RUN: %target-swift-emit-silgen -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=stub -target %target-cpu-apple-ios13.1-macabi -application-extension | %FileCheck %s --check-prefixes=CHECK,CHECK-EXTENSION
+
+// REQUIRES: OS=macosx || OS=maccatalyst
+
+public struct S {}
+
+// CHECK-LABEL: sil{{.*}}@$s4Test22macCatalystUnavailableAA1SVyF
+// CHECK-NOT:     _diagnoseUnavailableCodeReached
+// CHECK:       } // end sil function '$s4Test22macCatalystUnavailableAA1SVyF'
+@available(macCatalyst, unavailable)
+public func macCatalystUnavailable() -> S {
+  return S()
+}
+
+// CHECK-LABEL: sil{{.*}}@$s4Test14iOSUnavailableAA1SVyF
+// CHECK:         [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyFTwb : $@convention(thin) () -> Never
+// CHECK-NEXT:    [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK:       } // end sil function '$s4Test14iOSUnavailableAA1SVyF'
+@available(iOS, unavailable)
+public func iOSUnavailable() -> S {
+  return S()
+}
+
+// CHECK-LABEL: sil{{.*}}@$s4Test16macOSUnavailableAA1SVyF
+// CHECK-NOT:     _diagnoseUnavailableCodeReached
+// CHECK:       } // end sil function '$s4Test16macOSUnavailableAA1SVyF'
+@available(macOS, unavailable)
+public func macOSUnavailable() -> S {
+  return S()
+}
+
+// CHECK-LABEL: sil{{.*}}@$s4Test34iOSUnavailableMacCatalystAvailableAA1SVyF
+// CHECK-NOT:     _diagnoseUnavailableCodeReached
+// CHECK:       } // end sil function '$s4Test34iOSUnavailableMacCatalystAvailableAA1SVyF'
+@available(iOS, unavailable)
+@available(macCatalyst, introduced: 1.0)
+public func iOSUnavailableMacCatalystAvailable() -> S {
+  return S()
+}
+
+// CHECK-LABEL: sil{{.*}}@$s4Test28iOSAndMacCatalystUnavailableAA1SVyF
+// CHECK:         [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyFTwb : $@convention(thin) () -> Never
+// CHECK-NEXT:    [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK:       } // end sil function '$s4Test28iOSAndMacCatalystUnavailableAA1SVyF'
+@available(iOS, unavailable)
+@available(macCatalyst, unavailable)
+public func iOSAndMacCatalystUnavailable() -> S {
+  return S()
+}
+
+// CHECK-LABEL:              sil{{.*}}@$s4Test20iOSAppExtensionsOnlyAA1SVyF
+// CHECK-NO-EXTENSION:         [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyFTwb : $@convention(thin) () -> Never
+// CHECK-NO-EXTENSION-NEXT:    [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK-EXTENSION-NOT:        _diagnoseUnavailableCodeReached
+// CHECK:                    } // end sil function '$s4Test20iOSAppExtensionsOnlyAA1SVyF'
+@available(iOS, unavailable)
+@available(macCatalyst, unavailable)
+@available(iOSApplicationExtension, introduced: 1.0)
+public func iOSAppExtensionsOnly() -> S {
+  return S()
+}
+
+// CHECK-LABEL:              sil{{.*}}@$s4Test28macCatalystAppExtensionsOnlyAA1SVyF
+// CHECK-NO-EXTENSION:         [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyFTwb : $@convention(thin) () -> Never
+// CHECK-NO-EXTENSION-NEXT:    [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK-EXTENSION-NOT:        _diagnoseUnavailableCodeReached
+// CHECK:                    } // end sil function '$s4Test28macCatalystAppExtensionsOnlyAA1SVyF'
+@available(iOS, unavailable)
+@available(macCatalyst, unavailable)
+@available(macCatalystApplicationExtension, introduced: 1.0)
+public func macCatalystAppExtensionsOnly() -> S {
+  return S()
+}
+
+@available(macCatalyst, unavailable)
+public struct UnavailableOnMacCatalyst {
+  // CHECK-LABEL: sil{{.*}}@$s4Test24UnavailableOnMacCatalystV14noAvailabilityAA1SVyF
+  // CHECK-NOT:     _diagnoseUnavailableCodeReached
+  // CHECK:       } // end sil function '$s4Test24UnavailableOnMacCatalystV14noAvailabilityAA1SVyF'
+  public func noAvailability() -> S {
+    return S()
+  }
+
+  // CHECK-LABEL: sil{{.*}}@$s4Test24UnavailableOnMacCatalystV022iOSUnavailableInheritsdeB0AA1SVyF
+  // CHECK:         [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyFTwb : $@convention(thin) () -> Never
+  // CHECK-NEXT:    [[APPLY:%.*]] = apply [[FNREF]]()
+  // CHECK:       } // end sil function '$s4Test24UnavailableOnMacCatalystV022iOSUnavailableInheritsdeB0AA1SVyF'
+  @available(iOS, unavailable)
+  public func iOSUnavailableInheritsMacCatalystUnavailable() -> S {
+    return S()
+  }
+}
diff --git a/test/SILGen/unavailable_decl_optimization_stub_macos_zippered.swift b/test/SILGen/unavailable_decl_optimization_stub_macos_zippered.swift
diff --git a/test/SILGen/unavailable_decl_optimization_stub_visionos.swift b/test/SILGen/unavailable_decl_optimization_stub_visionos.swift
