Merge pull request #80051 from tshortli/refactor-semantic-decl-availability-request

AST: Introduce `DeclRuntimeAvailability`

Author: tshortli

include/swift/AST/AvailabilityConstraint.h

@@ -170,6 +170,10 @@ enum class AvailabilityConstraintFlag : uint8_t {
   /// referencing the extension. When this flag is specified, though, only the
   /// attributes directly attached to the declaration are considered.
   SkipEnclosingExtension = 1 << 0,
+
+  /// Include constraints for all domains, regardless of whether they are active
+  /// or relevant to type checking.
+  IncludeAllDomains = 1 << 1,
 };
 using AvailabilityConstraintFlags = OptionSet<AvailabilityConstraintFlag>;
 

include/swift/AST/Decl.h

@@ -1475,11 +1475,6 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// extension) that makes it unavailable.
   std::optional<SemanticAvailableAttr> getUnavailableAttr() const;
 
-  /// Returns true if the decl is effectively always unavailable in the current
-  /// compilation context. This query differs from \c isUnavailable() because it
-  /// takes the availability of parent declarations into account.
-  bool isSemanticallyUnavailable() const;
-
   /// Returns true if code associated with this declaration should be considerd
   /// unreachable at runtime because the declaration is unavailable in all
   /// execution contexts in which the code may run. This result takes the

include/swift/AST/TypeCheckRequests.h

@@ -4128,35 +4128,45 @@ class RenamedDeclRequest
   void cacheResult(ValueDecl *value) const;
 };
 
-enum class SemanticDeclAvailability : uint8_t {
-  /// The decl is potentially available in some contexts and/or under certain
-  /// deployment conditions.
+/// Describes the runtime availability of a declaration, which is a
+/// classification of whether a decl can be used at runtime (as opposed to
+/// compile time).
+///
+/// The elements of this enumeration must be ordered from most available to
+/// least available.
+enum class DeclRuntimeAvailability : uint8_t {
+  /// The decl is potentially available at runtime. If it is unavailable at
+  /// compile time in the current module, it may still be considered available
+  /// at compile time by other modules with different settings. For example, a
+  /// decl that is obsolete in Swift 5 is still available to other modules that
+  /// are compiled for an earlier language mode.
   PotentiallyAvailable,
 
-  /// The decl is always unavailable in the current compilation context.
-  /// However, it may still be used at runtime by other modules with different
-  /// settings. For example a decl that is obsolete in Swift 5 is still
-  /// available to other modules compiled for an earlier language mode.
-  ConditionallyUnavailable,
-
-  /// The decl is universally unavailable. For example, when compiling for macOS
-  /// a decl with `@available(macOS, unavailable)` can never be used (except in
-  /// contexts that are also completely unavailable on macOS).
-  CompletelyUnavailable,
-};
-
-class SemanticDeclAvailabilityRequest
-    : public SimpleRequest<SemanticDeclAvailabilityRequest,
-                           SemanticDeclAvailability(const Decl *decl),
+  /// The decl is always unavailable at compile time in the current module and
+  /// all other modules, but it is still required to be present at load time to
+  /// maintain ABI compatibility. For example, when compiling for macOS a decl
+  /// with an `@available(macOS, unavailable)` attribute can never be invoked,
+  /// except in contexts that are also completely unavailable on macOS. This
+  /// means the declaration is unreachable by execution at runtime, but the
+  /// decl's symbols may still have been strongly linked by other binaries built
+  /// by older versions of the compiler which may have emitted unavailable code
+  /// with strong references. To preserve ABI stability, the decl must still be
+  /// emitted.
+  AlwaysUnavailableABICompatible,
+};
+
+class DeclRuntimeAvailabilityRequest
+    : public SimpleRequest<DeclRuntimeAvailabilityRequest,
+                           DeclRuntimeAvailability(const Decl *decl),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  SemanticDeclAvailability evaluate(Evaluator &evaluator,
-                                    const Decl *decl) const;
+  DeclRuntimeAvailability evaluate(Evaluator &evaluator,
+                                   const Decl *decl) const;
 
 public:
   bool isCached() const { return true; }

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -473,8 +473,8 @@ SWIFT_REQUEST(TypeChecker, ImplicitKnownProtocolConformanceRequest,
 SWIFT_REQUEST(TypeChecker, RenamedDeclRequest,
               ValueDecl *(const ValueDecl *, const AvailableAttr *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, SemanticDeclAvailabilityRequest,
-              SemanticDeclAvailability(const Decl *),
+SWIFT_REQUEST(TypeChecker, DeclRuntimeAvailabilityRequest,
+              DeclRuntimeAvailability(const Decl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ClosureEffectsRequest,
               FunctionType::ExtInfo(ClosureExpr *),

lib/AST/Availability.cpp

@@ -541,122 +541,120 @@ std::optional<SemanticAvailableAttr> Decl::getUnavailableAttr() const {
   return std::nullopt;
 }
 
-static llvm::SmallVector<AvailabilityDomain, 2>
+static llvm::SmallSetVector<AvailabilityDomain, 2>
 availabilityDomainsForABICompatibility(const ASTContext &ctx) {
-  llvm::SmallVector<AvailabilityDomain, 2> domains;
+  llvm::SmallSetVector<AvailabilityDomain, 2> domains;
 
   // Regardless of target platform, binaries built for Embedded do not require
   // compatibility.
   if (ctx.LangOpts.hasFeature(Feature::Embedded))
     return domains;
 
   if (auto targetDomain = AvailabilityDomain::forTargetPlatform(ctx))
-    domains.push_back(targetDomain->getABICompatibilityDomain());
-  
+    domains.insert(targetDomain->getABICompatibilityDomain());
+
   if (auto variantDomain = AvailabilityDomain::forTargetVariantPlatform(ctx))
-    domains.push_back(variantDomain->getABICompatibilityDomain());
+    domains.insert(variantDomain->getABICompatibilityDomain());
 
   return domains;
 }
 
-/// Returns true if \p decl is proven to be unavailable for all platforms that
-/// external modules interacting with this module could target. A declaration
-/// that is not proven to be unavailable in this way could be reachable at
-/// runtime, even if it is unavailable to all code in this module.
-static bool isUnavailableForAllABICompatiblePlatforms(const Decl *decl) {
+static bool constraintIndicatesRuntimeUnavailability(
+    const AvailabilityConstraint &constraint, const ASTContext &ctx) {
+  switch (constraint.getReason()) {
+  case AvailabilityConstraint::Reason::UnconditionallyUnavailable: {
+    return true;
+  }
+  case AvailabilityConstraint::Reason::UnavailableForDeployment:
+  case AvailabilityConstraint::Reason::Obsoleted:
+  case AvailabilityConstraint::Reason::PotentiallyUnavailable:
+    return false;
+  }
+}
+
+/// Computes the `DeclRuntimeAvailability` value for `decl`.
+static DeclRuntimeAvailability getDeclRuntimeAvailability(const Decl *decl) {
   // Don't trust unavailability on declarations from Clang modules.
   if (isa<ClangModuleUnit>(decl->getDeclContext()->getModuleScopeContext()))
-    return false;
+    return DeclRuntimeAvailability::PotentiallyAvailable;
+
+  // Check whether the decl is unavailable at all.
+  if (!decl->isUnavailable())
+    return DeclRuntimeAvailability::PotentiallyAvailable;
 
   auto &ctx = decl->getASTContext();
-  llvm::SmallVector<AvailabilityDomain, 2> compatibilityDomains =
-      availabilityDomainsForABICompatibility(ctx);
-
-  llvm::SmallSet<AvailabilityDomain, 8> unavailableDescendantDomains;
-  llvm::SmallSet<AvailabilityDomain, 8> availableDescendantDomains;
-
-  // Build up the collection of relevant available and unavailable platform
-  // domains by looking at all the @available attributes. Along the way, we
-  // may find an attribute that makes the declaration universally unavailable
-  // in which case platform availability is irrelevant.
-  for (auto attr : decl->getSemanticAvailableAttrs(/*includeInactive=*/true)) {
-    auto domain = attr.getDomain();
+  auto compatibilityDomains = availabilityDomainsForABICompatibility(ctx);
+  auto potentiallyAvailableDomains = compatibilityDomains;
+
+  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.
+  flags |= AvailabilityConstraintFlag::IncludeAllDomains;
+
+  auto constraints = getAvailabilityConstraintsForDecl(
+      decl, AvailabilityContext::forInliningTarget(ctx), flags);
+
+  for (auto constraint : constraints) {
+    if (!constraintIndicatesRuntimeUnavailability(constraint, ctx))
+      continue;
+
+    // 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)
+      continue;
+
     if (isCompabilityDomainDescendant) {
-      // Record the whether the descendant domain is marked available
-      // or unavailable. Unavailability overrides availability.
-      if (attr.isUnconditionallyUnavailable()) {
-        availableDescendantDomains.erase(domain);
-        unavailableDescendantDomains.insert(domain);
-      } else if (!unavailableDescendantDomains.contains(domain)) {
-        availableDescendantDomains.insert(domain);
-      }
-    } else if (attr.isActive(ctx)) {
-      // The declaration is always unavailable if an active attribute from a
-      // domain outside the compatibility hierarchy indicates unavailability.
-      if (attr.isUnconditionallyUnavailable())
-        return true;
+      // 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 there aren't any compatibility domains to check and we didn't find any
-  // other active attributes that make the declaration unavailable, then it must
-  // be available.
-  if (compatibilityDomains.empty())
-    return false;
-
-  // Verify that the declaration has been marked unavailable in every
-  // compatibility domain.
-  for (auto compatibilityDomain : compatibilityDomains) {
-    if (!unavailableDescendantDomains.contains(compatibilityDomain))
-      return false;
+    // Either every compatibility domain has been proven unavailable or this
+    // constraint proves runtime unavailability on its own.
+    return DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
   }
-  
-  // Verify that there aren't any explicitly available descendant domains.
-  if (availableDescendantDomains.size() > 0)
-    return false;
 
-  return true;
+  return DeclRuntimeAvailability::PotentiallyAvailable;
 }
 
-SemanticDeclAvailability
-SemanticDeclAvailabilityRequest::evaluate(Evaluator &evaluator,
-                                          const Decl *decl) const {
-  auto inherited = SemanticDeclAvailability::PotentiallyAvailable;
+DeclRuntimeAvailability
+DeclRuntimeAvailabilityRequest::evaluate(Evaluator &evaluator,
+                                         const Decl *decl) const {
+  auto inherited = DeclRuntimeAvailability::PotentiallyAvailable;
   if (auto *parent =
           AvailabilityInference::parentDeclForInferredAvailability(decl)) {
     inherited = evaluateOrDefault(
-        evaluator, SemanticDeclAvailabilityRequest{parent}, inherited);
+        evaluator, DeclRuntimeAvailabilityRequest{parent}, inherited);
   }
 
-  if (inherited == SemanticDeclAvailability::CompletelyUnavailable ||
-      isUnavailableForAllABICompatiblePlatforms(decl))
-    return SemanticDeclAvailability::CompletelyUnavailable;
-
-  if (inherited == SemanticDeclAvailability::ConditionallyUnavailable ||
-      decl->isUnavailable())
-    return SemanticDeclAvailability::ConditionallyUnavailable;
-
-  return SemanticDeclAvailability::PotentiallyAvailable;
-}
+  // If the inherited semantic availability is already maximally unavailable
+  // then skip computing unavailability for this declaration.
+  if (inherited == DeclRuntimeAvailability::AlwaysUnavailableABICompatible)
+    return DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
 
-bool Decl::isSemanticallyUnavailable() const {
-  auto availability = evaluateOrDefault(
-      getASTContext().evaluator, SemanticDeclAvailabilityRequest{this},
-      SemanticDeclAvailability::PotentiallyAvailable);
-  return availability != SemanticDeclAvailability::PotentiallyAvailable;
+  auto availability = getDeclRuntimeAvailability(decl);
+  return std::max(inherited, availability);
 }
 
 bool Decl::isUnreachableAtRuntime() const {
   auto availability = evaluateOrDefault(
-      getASTContext().evaluator, SemanticDeclAvailabilityRequest{this},
-      SemanticDeclAvailability::PotentiallyAvailable);
-  return availability == SemanticDeclAvailability::CompletelyUnavailable;
+      getASTContext().evaluator, DeclRuntimeAvailabilityRequest{this},
+      DeclRuntimeAvailability::PotentiallyAvailable);
+  return availability ==
+         DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
 }
 
 static UnavailableDeclOptimization
@@ -859,8 +857,6 @@ std::optional<llvm::VersionTuple> SemanticAvailableAttr::getIntroduced() const {
 
 std::optional<AvailabilityRange>
 SemanticAvailableAttr::getIntroducedRange(const ASTContext &Ctx) const {
-  DEBUG_ASSERT(getDomain().isActive(Ctx));
-
   auto *attr = getParsedAttr();
   if (!attr->getRawIntroduced().has_value()) {
     // For versioned domains, an "introduced:" version is always required to
@@ -899,8 +895,6 @@ std::optional<llvm::VersionTuple> SemanticAvailableAttr::getDeprecated() const {
 
 std::optional<AvailabilityRange>
 SemanticAvailableAttr::getDeprecatedRange(const ASTContext &Ctx) const {
-  DEBUG_ASSERT(getDomain().isActive(Ctx));
-
   auto *attr = getParsedAttr();
   if (!attr->getRawDeprecated().has_value()) {
     // Regardless of the whether the domain supports versions or not, an
@@ -930,8 +924,6 @@ std::optional<llvm::VersionTuple> SemanticAvailableAttr::getObsoleted() const {
 
 std::optional<AvailabilityRange>
 SemanticAvailableAttr::getObsoletedRange(const ASTContext &Ctx) const {
-  DEBUG_ASSERT(getDomain().isActive(Ctx));
-
   auto *attr = getParsedAttr();
 
   // Obsoletion always requires a version.

lib/AST/AvailabilityConstraint.cpp

@@ -198,14 +198,15 @@ activePlatformDomainForDecl(const Decl *decl) {
 
 static void getAvailabilityConstraintsForDecl(
     llvm::SmallVector<AvailabilityConstraint, 4> &constraints, const Decl *decl,
-    const AvailabilityContext &context) {
+    const AvailabilityContext &context, AvailabilityConstraintFlags flags) {
   auto &ctx = decl->getASTContext();
   auto activePlatformDomain = activePlatformDomainForDecl(decl);
+  bool includeAllDomains =
+      flags.contains(AvailabilityConstraintFlag::IncludeAllDomains);
 
-  for (auto attr :
-       decl->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+  for (auto attr : decl->getSemanticAvailableAttrs(includeAllDomains)) {
     auto domain = attr.getDomain();
-    if (domain.isPlatform() && activePlatformDomain &&
+    if (!includeAllDomains && domain.isPlatform() && activePlatformDomain &&
         !activePlatformDomain->contains(domain))
       continue;
 
@@ -234,7 +235,7 @@ swift::getAvailabilityConstraintsForDecl(const Decl *decl,
 
   decl = decl->getAbstractSyntaxDeclForAttributes();
 
-  getAvailabilityConstraintsForDecl(constraints, decl, context);
+  getAvailabilityConstraintsForDecl(constraints, decl, context, flags);
 
   if (flags.contains(AvailabilityConstraintFlag::SkipEnclosingExtension))
     return constraints;
@@ -251,7 +252,7 @@ swift::getAvailabilityConstraintsForDecl(const Decl *decl,
 
   auto parent = AvailabilityInference::parentDeclForInferredAvailability(decl);
   if (auto extension = dyn_cast_or_null<ExtensionDecl>(parent))
-    getAvailabilityConstraintsForDecl(constraints, extension, context);
+    getAvailabilityConstraintsForDecl(constraints, extension, context, flags);
 
   return constraints;
 }

lib/SIL/IR/SILProfiler.cpp

@@ -12,6 +12,7 @@
 
 #include "swift/SIL/SILProfiler.h"
 #include "swift/AST/ASTWalker.h"
+#include "swift/AST/AvailabilityContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/Module.h"
@@ -117,7 +118,7 @@ static bool shouldProfile(SILDeclRef Constant) {
 
   if (auto *D = DC->getInnermostDeclarationDeclContext()) {
     // Do not profile AST nodes in unavailable contexts.
-    if (D->isSemanticallyUnavailable()) {
+    if (AvailabilityContext::forDeclSignature(D).isUnavailable()) {
       LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: unavailable context\n");
       return false;
     }

lib/Sema/TypeCheckAttr.cpp

@@ -5455,7 +5455,7 @@ TypeChecker::diagnosticIfDeclCannotBeUnavailable(const Decl *D,
   auto parentIsUnavailable = [](const Decl *D) -> bool {
     if (auto *parent =
             AvailabilityInference::parentDeclForInferredAvailability(D)) {
-      return parent->isSemanticallyUnavailable();
+      return AvailabilityContext::forDeclSignature(parent).isUnavailable();
     }
     return false;
   };

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1933,7 +1933,7 @@ checkOverrideUnavailability(ValueDecl *override, ValueDecl *base) {
   if (auto *overrideParent = override->getDeclContext()->getAsDecl()) {
     // If the parent of the override is unavailable, then the unavailability of
     // the override decl is irrelevant.
-    if (overrideParent->isSemanticallyUnavailable())
+    if (AvailabilityContext::forDeclSignature(overrideParent).isUnavailable())
       return {OverrideUnavailabilityStatus::Ignored, std::nullopt};
   }