AST: Enable -unavailable-code-optimization for zippered libraries.

Correct the determination of whether a declaration is unreachable at runtime
when compiling a zippered library.

Resolves rdar://125930716.

Author: tshortli

include/swift/AST/AvailabilityDomain.h

@@ -154,11 +154,16 @@ class AvailabilityDomain final {
     return AvailabilityDomain(domain);
   }
 
-  /// Returns the most specific platform domain that applies to the compilation
-  /// context.
+  /// Returns the most specific platform domain for the target of the
+  /// compilation context.
   static std::optional<AvailabilityDomain>
   forTargetPlatform(const ASTContext &ctx);
 
+  /// Returns the most specific platform domain for the target variant of the
+  /// compilation context.
+  static std::optional<AvailabilityDomain>
+  forTargetVariantPlatform(const ASTContext &ctx);
+
   /// Returns the built-in availability domain identified by the given string.
   static std::optional<AvailabilityDomain>
   builtinDomainForString(StringRef string, const DeclContext *declContext);

include/swift/AST/PlatformKind.h

@@ -83,6 +83,9 @@ bool isPlatformActive(PlatformKind Platform, const LangOptions &LangOpts,
 /// Returns the target platform for the given language options.
 PlatformKind targetPlatform(const LangOptions &LangOpts);
 
+/// Returns the target variant platform for the given language options.
+PlatformKind targetVariantPlatform(const LangOptions &LangOpts);
+
 /// Returns true when availability attributes from the "parent" platform
 /// should also apply to the "child" platform for declarations without
 /// an explicit attribute for the child.

lib/AST/Availability.cpp

@@ -642,6 +642,9 @@ availabilityDomainsForABICompatibility(const ASTContext &ctx) {
 
   if (auto targetDomain = AvailabilityDomain::forTargetPlatform(ctx))
     domains.push_back(targetDomain->getABICompatibilityDomain());
+  
+  if (auto variantDomain = AvailabilityDomain::forTargetVariantPlatform(ctx))
+    domains.push_back(variantDomain->getABICompatibilityDomain());
 
   return domains;
 }
@@ -708,13 +711,6 @@ static bool isUnavailableForAllABICompatiblePlatforms(const Decl *decl) {
   if (availableDescendantDomains.size() > 0)
     return false;
 
-  // FIXME: [availability] Support zippered frameworks (rdar://125371621)
-  // If we have a target variant (e.g. we're building a zippered macOS
-  // framework) then the decl is only unreachable if it is unavailable for both
-  // the primary target and the target variant.
-  if (decl->getASTContext().LangOpts.TargetVariant.has_value())
-    return false;
-
   return true;
 }
 

lib/AST/AvailabilityDomain.cpp

@@ -27,6 +27,15 @@ AvailabilityDomain::forTargetPlatform(const ASTContext &ctx) {
   return forPlatform(platform);
 }
 
+std::optional<AvailabilityDomain>
+AvailabilityDomain::forTargetVariantPlatform(const ASTContext &ctx) {
+  auto platform = swift::targetVariantPlatform(ctx.LangOpts);
+  if (platform == PlatformKind::none)
+    return std::nullopt;
+
+  return forPlatform(platform);
+}
+
 std::optional<AvailabilityDomain>
 AvailabilityDomain::builtinDomainForString(StringRef string,
                                            const DeclContext *declContext) {

lib/AST/PlatformKind.cpp

@@ -181,44 +181,58 @@ bool swift::isPlatformActive(PlatformKind Platform, const LangOptions &LangOpts,
                                    LangOpts.EnableAppExtensionRestrictions, ForRuntimeQuery);
 }
 
-PlatformKind swift::targetPlatform(const LangOptions &LangOpts) {
-  if (LangOpts.Target.isMacOSX()) {
-    return (LangOpts.EnableAppExtensionRestrictions
+static PlatformKind platformForTriple(const llvm::Triple &triple,
+                                      bool enableAppExtensionRestrictions) {
+  if (triple.isMacOSX()) {
+    return (enableAppExtensionRestrictions
                 ? PlatformKind::macOSApplicationExtension
                 : PlatformKind::macOS);
   }
 
-  if (LangOpts.Target.isTvOS()) {
-    return (LangOpts.EnableAppExtensionRestrictions
-            ? PlatformKind::tvOSApplicationExtension
-            : PlatformKind::tvOS);
+  if (triple.isTvOS()) {
+    return (enableAppExtensionRestrictions
+                ? PlatformKind::tvOSApplicationExtension
+                : PlatformKind::tvOS);
   }
 
-  if (LangOpts.Target.isWatchOS()) {
-    return (LangOpts.EnableAppExtensionRestrictions
-            ? PlatformKind::watchOSApplicationExtension
-            : PlatformKind::watchOS);
+  if (triple.isWatchOS()) {
+    return (enableAppExtensionRestrictions
+                ? PlatformKind::watchOSApplicationExtension
+                : PlatformKind::watchOS);
   }
 
-  if (LangOpts.Target.isiOS()) {
-    if (tripleIsMacCatalystEnvironment(LangOpts.Target))
-      return (LangOpts.EnableAppExtensionRestrictions
+  if (triple.isiOS()) {
+    if (tripleIsMacCatalystEnvironment(triple))
+      return (enableAppExtensionRestrictions
                   ? PlatformKind::macCatalystApplicationExtension
                   : PlatformKind::macCatalyst);
-    return (LangOpts.EnableAppExtensionRestrictions
+    return (enableAppExtensionRestrictions
                 ? PlatformKind::iOSApplicationExtension
                 : PlatformKind::iOS);
   }
 
-  if (LangOpts.Target.isXROS()) {
-    return (LangOpts.EnableAppExtensionRestrictions
-            ? PlatformKind::visionOSApplicationExtension
-            : PlatformKind::visionOS);
+  if (triple.isXROS()) {
+    return (enableAppExtensionRestrictions
+                ? PlatformKind::visionOSApplicationExtension
+                : PlatformKind::visionOS);
   }
 
   return PlatformKind::none;
 }
 
+PlatformKind swift::targetPlatform(const LangOptions &LangOpts) {
+  return platformForTriple(LangOpts.Target,
+                           LangOpts.EnableAppExtensionRestrictions);
+}
+
+PlatformKind swift::targetVariantPlatform(const LangOptions &LangOpts) {
+  if (auto variant = LangOpts.TargetVariant)
+    return platformForTriple(*LangOpts.TargetVariant,
+                             LangOpts.EnableAppExtensionRestrictions);
+
+  return PlatformKind::none;
+}
+
 bool swift::inheritsAvailabilityFromPlatform(PlatformKind Child,
                                              PlatformKind Parent) {
   if (auto ChildPlatformBase = basePlatformForExtensionPlatform(Child)) {

test/SILGen/unavailable_decl_optimization_stub_macos_zippered.swift

@@ -21,16 +21,15 @@ public func unavailableOnMacOSFunc() {}
 @available(iOS, unavailable)
 public func unavailableOniOSFunc() {}
 
-// FIXME: This function should diagnose (rdar://125930716)
 // CHECK-LABEL:     sil{{.*}}@$s4Test28unavailableOnMacCatalystFuncyyF
 // CHECK-NOT:         _diagnoseUnavailableCodeReached
 // CHECK:           } // end sil function '$s4Test28unavailableOnMacCatalystFuncyyF'
 @available(macCatalyst, unavailable)
 public func unavailableOnMacCatalystFunc() {}
 
-// FIXME: This function should diagnose (rdar://125930716)
 // CHECK-LABEL:     sil{{.*}}@$s4Test28unavailableOnMacOSAndiOSFuncyyF
-// CHECK-NOT:         _diagnoseUnavailableCodeReached
+// CHECK:             [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyFTwb : $@convention(thin) () -> Never
+// CHECK-NEXT:        [[APPLY:%.*]] = apply [[FNREF]]()
 // CHECK:           } // end sil function '$s4Test28unavailableOnMacOSAndiOSFuncyyF'
 @available(macOS, unavailable)
 @available(iOS, unavailable)
@@ -43,7 +42,7 @@ public struct UnavailableOniOS {
   // CHECK:           } // end sil function '$s4Test16UnavailableOniOSV15availableMethodyyF'
   public func availableMethod() {}
 
-  // FIXME: This function should diagnose (rdar://125930716)
+  // FIXME: [availability] This method should diagnose
   // CHECK-LABEL:     sil{{.*}}@$s4Test16UnavailableOniOSV24unavailableOnMacOSMethodyyF
   // CHECK-NOT:         _diagnoseUnavailableCodeReached
   // CHECK:           } // end sil function '$s4Test16UnavailableOniOSV24unavailableOnMacOSMethodyyF'

test/decl/enum/derived_hashable_equatable_macos_zippered.swift

@@ -47,12 +47,10 @@ enum HasElementsWithAvailability: Hashable {
   // CHECK-NEXT:      index_a = 2
   // CHECK-NEXT:    case .unavailableMacCatalyst:
   // CHECK-NEXT:      index_a = 3
-  // FIXME: This case should diagnose (rdar://125930716)
   // CHECK-NEXT:    case .unavailableMacOSAndiOS:
-  // CHECK-NEXT:      index_a = 4
-  // FIXME: This case should diagnose (rdar://125930716)
+  // CHECK-NEXT:      _diagnoseUnavailableCodeReached{{.*}}
   // CHECK-NEXT:    case .unavailableMacOSAndMacCatalyst:
-  // CHECK-NEXT:      index_a = 5
+  // CHECK-NEXT:      index_a = 4
   // CHECK-NEXT:    }
   // CHECK-NEXT:    var index_b: Int
   // CHECK-NEXT:    switch b {
@@ -66,12 +64,10 @@ enum HasElementsWithAvailability: Hashable {
   // CHECK-NEXT:      index_b = 2
   // CHECK-NEXT:    case .unavailableMacCatalyst:
   // CHECK-NEXT:      index_b = 3
-  // FIXME: This case should diagnose (rdar://125930716)
   // CHECK-NEXT:    case .unavailableMacOSAndiOS:
-  // CHECK-NEXT:      index_b = 4
-  // FIXME: This case should diagnose (rdar://125930716)
+  // CHECK-NEXT:      _diagnoseUnavailableCodeReached{{.*}}
   // CHECK-NEXT:    case .unavailableMacOSAndMacCatalyst:
-  // CHECK-NEXT:      index_b = 5
+  // CHECK-NEXT:      index_b = 4
   // CHECK-NEXT:    }
   // CHECK-NEXT:    return index_a == index_b
   // CHECK-NEXT:  }
@@ -89,12 +85,10 @@ enum HasElementsWithAvailability: Hashable {
   // CHECK-NEXT:      discriminator = 2
   // CHECK-NEXT:    case .unavailableMacCatalyst:
   // CHECK-NEXT:      discriminator = 3
-  // FIXME: This case should diagnose (rdar://125930716)
   // CHECK-NEXT:    case .unavailableMacOSAndiOS:
-  // CHECK-NEXT:      discriminator = 4
-  // FIXME: This case should diagnose (rdar://125930716)
+  // CHECK-NEXT:      _diagnoseUnavailableCodeReached{{.*}}
   // CHECK-NEXT:    case .unavailableMacOSAndMacCatalyst:
-  // CHECK-NEXT:      discriminator = 5
+  // CHECK-NEXT:      discriminator = 4
   // CHECK-NEXT:    }
   // CHECK-NEXT:    hasher.combine(discriminator)
   // CHECK-NEXT:  }