Merge pull request #80084 from tshortli/custom-domain-runtime-availability

AST: Skip SILGen for decls that are unavailable in custom domains

Author: tshortli

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;
 
@@ -251,10 +254,14 @@ class AvailabilityDomain final {
   /// universal domain (`*`) is the bottom element.
   bool contains(const AvailabilityDomain &other) const;
 
-  /// Returns the root availability domain that this domain must be compatible
-  /// with. For example, macCatalyst and visionOS must both be ABI compatible
-  /// with iOS. The compatible domain must contain this domain.
-  AvailabilityDomain getABICompatibilityDomain() const;
+  /// Returns true for domains that are not contained by any domain other than
+  /// the universal domain.
+  bool isRoot() const;
+
+  /// Returns the root availability domain that contains this domain (see
+  /// `isRoot()`). For example, macCatalyst and visionOS are both ultimately
+  /// descendants of the iOS domain.
+  AvailabilityDomain getRootDomain() const;
 
   bool operator==(const AvailabilityDomain &other) const {
     return storage.getOpaqueValue() == other.storage.getOpaqueValue();

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

lib/AST/Availability.cpp

@@ -541,8 +541,10 @@ std::optional<SemanticAvailableAttr> Decl::getUnavailableAttr() const {
   return std::nullopt;
 }
 
+/// Returns the mutually exclusive root platform domains that must all be
+/// unavailable in order for a declaration to be unavailable at runtime.
 static llvm::SmallSetVector<AvailabilityDomain, 2>
-availabilityDomainsForABICompatibility(const ASTContext &ctx) {
+getRootTargetDomains(const ASTContext &ctx) {
   llvm::SmallSetVector<AvailabilityDomain, 2> domains;
 
   // Regardless of target platform, binaries built for Embedded do not require
@@ -551,83 +553,132 @@ availabilityDomainsForABICompatibility(const ASTContext &ctx) {
     return domains;
 
   if (auto targetDomain = AvailabilityDomain::forTargetPlatform(ctx))
-    domains.insert(targetDomain->getABICompatibilityDomain());
+    domains.insert(targetDomain->getRootDomain());
 
   if (auto variantDomain = AvailabilityDomain::forTargetVariantPlatform(ctx))
-    domains.insert(variantDomain->getABICompatibilityDomain());
+    domains.insert(variantDomain->getRootDomain());
 
   return domains;
 }
 
 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;
   }
 }
 
-/// Computes the `DeclRuntimeAvailability` value for `decl`.
-static DeclRuntimeAvailability getDeclRuntimeAvailability(const Decl *decl) {
+/// 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 compatibilityDomains = availabilityDomainsForABICompatibility(ctx);
-  auto potentiallyAvailableDomains = compatibilityDomains;
+  auto rootTargetDomains = getRootTargetDomains(ctx);
+  auto remainingTargetDomains = rootTargetDomains;
 
   AvailabilityConstraintFlags flags;
 
   // Semantic availability was already computed separately for any enclosing
   // 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 isCompabilityDomainDescendant =
-        llvm::find_if(compatibilityDomains,
-                      [&domain](AvailabilityDomain compatibilityDomain) {
-                        return compatibilityDomain.contains(domain);
-                      }) != compatibilityDomains.end();
-
-    if (!domain.isActive(ctx) && !isCompabilityDomainDescendant)
+    bool isTargetDomain = rootTargetDomains.contains(domain);
+    if (!domain.isActive(ctx) && !isTargetDomain)
       continue;
 
-    if (isCompabilityDomainDescendant) {
-      // If the decl is still potentially available in some compatibility
-      // domain, keep looking at the remaining constraints.
-      potentiallyAvailableDomains.remove(domain);
-      if (!potentiallyAvailableDomains.empty())
-        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) {
+      remainingTargetDomains.remove(domain);
+      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
+/// `DeclRuntimeAvailabilityRequest`.
+static DeclRuntimeAvailability getDeclRuntimeAvailability(const Decl *decl) {
+  return evaluateOrDefault(decl->getASTContext().evaluator,
+                           DeclRuntimeAvailabilityRequest{decl},
+                           DeclRuntimeAvailability::PotentiallyAvailable);
 }
 
 DeclRuntimeAvailability
@@ -636,24 +687,20 @@ DeclRuntimeAvailabilityRequest::evaluate(Evaluator &evaluator,
   auto inherited = DeclRuntimeAvailability::PotentiallyAvailable;
   if (auto *parent =
           AvailabilityInference::parentDeclForInferredAvailability(decl)) {
-    inherited = evaluateOrDefault(
-        evaluator, DeclRuntimeAvailabilityRequest{parent}, inherited);
+    inherited = getDeclRuntimeAvailability(parent);
   }
 
-  // If the inherited semantic availability is already maximally unavailable
+  // 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 = getDeclRuntimeAvailability(decl);
+  auto availability = computeDeclRuntimeAvailability(decl);
   return std::max(inherited, availability);
 }
 
 bool Decl::isUnreachableAtRuntime() const {
-  auto availability = evaluateOrDefault(
-      getASTContext().evaluator, DeclRuntimeAvailabilityRequest{this},
-      DeclRuntimeAvailability::PotentiallyAvailable);
-  return availability ==
+  return getDeclRuntimeAvailability(this) >=
          DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
 }
 
@@ -666,13 +713,15 @@ getEffectiveUnavailableDeclOptimization(ASTContext &ctx) {
 }
 
 bool Decl::isAvailableDuringLowering() const {
-  // Unconditionally unavailable declarations should be skipped during lowering
-  // when -unavailable-decl-optimization=complete is specified.
+  auto availability = getDeclRuntimeAvailability(this);
+
   if (getEffectiveUnavailableDeclOptimization(getASTContext()) !=
       UnavailableDeclOptimization::Complete)
-    return true;
+    return availability < DeclRuntimeAvailability::AlwaysUnavailable;
 
-  return !isUnreachableAtRuntime();
+  // All unreachable declarations should be skipped during lowering
+  // when -unavailable-decl-optimization=complete is specified.
+  return availability < DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
 }
 
 bool Decl::requiresUnavailableDeclABICompatibilityStubs() const {

lib/AST/AvailabilityDomain.cpp

@@ -121,10 +121,8 @@ bool AvailabilityDomain::isActive(const ASTContext &ctx) const {
 bool AvailabilityDomain::isActiveForTargetPlatform(
     const ASTContext &ctx) const {
   if (isPlatform()) {
-    if (auto targetDomain = AvailabilityDomain::forTargetPlatform(ctx)) {
-      auto compatibleDomain = targetDomain->getABICompatibilityDomain();
-      return compatibleDomain.contains(*this);
-    }
+    if (auto targetDomain = AvailabilityDomain::forTargetPlatform(ctx))
+      return targetDomain->getRootDomain().contains(*this);
   }
   return false;
 }
@@ -212,14 +210,31 @@ bool AvailabilityDomain::contains(const AvailabilityDomain &other) const {
   }
 }
 
-AvailabilityDomain AvailabilityDomain::getABICompatibilityDomain() const {
+bool AvailabilityDomain::isRoot() const {
+  switch (getKind()) {
+  case AvailabilityDomain::Kind::Universal:
+  case AvailabilityDomain::Kind::Embedded:
+  case AvailabilityDomain::Kind::SwiftLanguage:
+  case AvailabilityDomain::Kind::PackageDescription:
+    return true;
+  case AvailabilityDomain::Kind::Platform:
+    return getRootDomain() == *this;
+  case AvailabilityDomain::Kind::Custom:
+    // For now, all custom domains are their own root.
+    return true;
+  }
+}
+
+AvailabilityDomain AvailabilityDomain::getRootDomain() const {
   if (!isPlatform())
     return *this;
 
+  // iOS specifically contains a few other platforms.
   auto iOSDomain = AvailabilityDomain::forPlatform(PlatformKind::iOS);
   if (iOSDomain.contains(*this))
     return iOSDomain;
 
+  // App Extension domains are contained by their base platform domain.
   if (auto basePlatform = basePlatformForExtensionPlatform(getPlatformKind()))
     return AvailabilityDomain::forPlatform(*basePlatform);
 

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.
   };