AST: Refactor SemanticDeclAvailabilityRequest.

Generalize the implementation of `SemanticDeclAvailabilityRequest` in
preparation for adding a new case to `SemanticDeclAvailability`. Use the
centralized availability constraint query instead of implementing a bespoke
algorithm for gathering constraints. Simplify `SemanticDeclAvailability` by
removing a case that is no longer relevant.

Part of rdar://138441307.

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/TypeCheckRequests.h

@@ -4128,21 +4128,31 @@ class RenamedDeclRequest
   void cacheResult(ValueDecl *value) const;
 };
 
+/// 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 SemanticDeclAvailability : uint8_t {
-  /// The decl is potentially available in some contexts and/or under certain
-  /// deployment conditions.
+  /// 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,
+  /// 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 SemanticDeclAvailabilityRequest

lib/AST/Availability.cpp

@@ -541,87 +541,93 @@ 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 `SemanticDeclAvailability` value for `decl`.
+static SemanticDeclAvailability getSemanticDeclAvailability(const Decl *decl) {
   // Don't trust unavailability on declarations from Clang modules.
   if (isa<ClangModuleUnit>(decl->getDeclContext()->getModuleScopeContext()))
-    return false;
+    return SemanticDeclAvailability::PotentiallyAvailable;
+
+  // Check whether the decl is unavailable at all.
+  if (!decl->isUnavailable())
+    return SemanticDeclAvailability::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 SemanticDeclAvailability::AlwaysUnavailableABICompatible;
   }
-  
-  // Verify that there aren't any explicitly available descendant domains.
-  if (availableDescendantDomains.size() > 0)
-    return false;
 
-  return true;
+  return SemanticDeclAvailability::PotentiallyAvailable;
 }
 
 SemanticDeclAvailability
@@ -634,22 +640,21 @@ SemanticDeclAvailabilityRequest::evaluate(Evaluator &evaluator,
         evaluator, SemanticDeclAvailabilityRequest{parent}, inherited);
   }
 
-  if (inherited == SemanticDeclAvailability::CompletelyUnavailable ||
-      isUnavailableForAllABICompatiblePlatforms(decl))
-    return SemanticDeclAvailability::CompletelyUnavailable;
-
-  if (inherited == SemanticDeclAvailability::ConditionallyUnavailable ||
-      decl->isUnavailable())
-    return SemanticDeclAvailability::ConditionallyUnavailable;
+  // If the inherited semantic availability is already maximally unavailable
+  // then skip computing unavailability for this declaration.
+  if (inherited == SemanticDeclAvailability::AlwaysUnavailableABICompatible)
+    return SemanticDeclAvailability::AlwaysUnavailableABICompatible;
 
-  return SemanticDeclAvailability::PotentiallyAvailable;
+  auto availability = getSemanticDeclAvailability(decl);
+  return std::max(inherited, availability);
 }
 
 bool Decl::isUnreachableAtRuntime() const {
   auto availability = evaluateOrDefault(
       getASTContext().evaluator, SemanticDeclAvailabilityRequest{this},
       SemanticDeclAvailability::PotentiallyAvailable);
-  return availability == SemanticDeclAvailability::CompletelyUnavailable;
+  return availability ==
+         SemanticDeclAvailability::AlwaysUnavailableABICompatible;
 }
 
 static UnavailableDeclOptimization
@@ -852,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
@@ -892,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
@@ -923,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;
 }

test/SILGen/unavailable_decl_optimization_stub.swift

@@ -90,3 +90,9 @@ public func obsoletedInSwift1() {}
 // CHECK:       } // end sil function '$s4Test17obsoletedInSwift5yyF'
 @available(swift, obsoleted: 5)
 public func obsoletedInSwift5() {}
+
+// CHECK-LABEL: sil{{.*}}@$s4Test19introducedInSwift99yyF : $@convention(thin) () -> () {
+// CHECK-NOT:     ss36_diagnoseUnavailableCodeReached
+// CHECK:       } // end sil function '$s4Test19introducedInSwift99yyF'
+@available(swift, introduced: 99)
+public func introducedInSwift99() {}

test/SILGen/unavailable_decl_optimization_stub_macos.swift

@@ -1,5 +1,5 @@
-// RUN: %target-swift-emit-silgen -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=stub | %FileCheck %s --check-prefixes=CHECK
-// RUN: %target-swift-emit-silgen -target %target-swift-5.8-abi-triple -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=stub -application-extension | %FileCheck %s --check-prefixes=CHECK
+// RUN: %target-swift-emit-silgen -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=stub | %FileCheck %s --check-prefixes=CHECK,CHECK-NO-EXTENSION
+// RUN: %target-swift-emit-silgen -target %target-swift-5.8-abi-triple -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=stub -application-extension | %FileCheck %s --check-prefixes=CHECK,CHECK-EXTENSION
 
 // REQUIRES: OS=macosx
 
@@ -38,8 +38,10 @@ public func unavailableOnMacOSExtensionFunc() {}
 @available(macOSApplicationExtension, unavailable) // FIXME: Seems like this should be diagnosed as redundant
 public func unavailableOnMacOSAndMacOSExtensionFunc() {}
 
-// CHECK-LABEL:     sil{{.*}}@$s4Test33availableOnMacOSExtensionOnlyFuncyyF
-// CHECK-NOT:         _diagnoseUnavailableCodeReached
+// CHECK-LABEL:             sil{{.*}}@$s4Test33availableOnMacOSExtensionOnlyFuncyyF
+// 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 '$s4Test33availableOnMacOSExtensionOnlyFuncyyF'
 @available(macOS, unavailable)
 @available(macOSApplicationExtension, introduced: 10.9)
@@ -56,3 +58,44 @@ public func unavailableOniOSFunc() {}
 // CHECK:           } // end sil function '$s4Test20obsoletedOnMacOS10_9yyF'
 @available(macOS, obsoleted: 10.9)
 public func obsoletedOnMacOS10_9() {}
+
+// CHECK-LABEL:     sil{{.*}}@$s4Test19introducedInMacOS99yyF
+// CHECK-NOT:         _diagnoseUnavailableCodeReached
+// CHECK:           } // end sil function '$s4Test19introducedInMacOS99yyF'
+@available(macOS, introduced: 99)
+public func introducedInMacOS99() {}
+
+// CHECK-LABEL:     sil{{.*}}@$s4Test28unavailableIntroducedInMacOSyyF
+// CHECK:             [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyFTwb : $@convention(thin) () -> Never
+// CHECK-NEXT:        [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK:           } // end sil function '$s4Test28unavailableIntroducedInMacOSyyF'
+@available(macOS, unavailable, introduced: 10.9)
+public func unavailableIntroducedInMacOS() {}
+
+// CHECK-LABEL:     sil{{.*}}@$s4Test31unavailableAndIntroducedInMacOSyyF
+// CHECK:             [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyFTwb : $@convention(thin) () -> Never
+// CHECK-NEXT:        [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK:           } // end sil function '$s4Test31unavailableAndIntroducedInMacOSyyF'
+@available(macOS, unavailable)
+@available(macOS, introduced: 10.9)
+public func unavailableAndIntroducedInMacOS() {}
+
+// CHECK-LABEL:     sil{{.*}}@$s4Test31introducedAndUnavailableInMacOSyyF
+// CHECK:             [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyFTwb : $@convention(thin) () -> Never
+// CHECK-NEXT:        [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK:           } // end sil function '$s4Test31introducedAndUnavailableInMacOSyyF'
+@available(macOS, introduced: 10.9)
+@available(macOS, unavailable)
+public func introducedAndUnavailableInMacOS() {}
+
+// CHECK-LABEL:     sil{{.*}}@$s4Test17deprecatedInMacOSyyF
+// CHECK-NOT:         _diagnoseUnavailableCodeReached
+// CHECK:           } // end sil function '$s4Test17deprecatedInMacOSyyF'
+@available(macOS, deprecated)
+public func deprecatedInMacOS() {}
+
+// CHECK-LABEL:     sil{{.*}}@$s4Test21deprecatedInMacOS10_9yyF
+// CHECK-NOT:         _diagnoseUnavailableCodeReached
+// CHECK:           } // end sil function '$s4Test21deprecatedInMacOS10_9yyF'
+@available(macOS, deprecated: 10.9)
+public func deprecatedInMacOS10_9() {}