Merge pull request #77907 from tshortli/semantic-decl-availability

AST: Refactor semantic unavailability queries

Author: tshortli

include/swift/AST/Decl.h

@@ -1442,22 +1442,15 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   std::optional<std::pair<const AvailableAttr *, const Decl *>>
   getSemanticAvailableRangeAttr() const;
 
-  /// Retrieve the @available attribute that makes this declaration unavailable,
-  /// if any. If \p ignoreAppExtensions is true then attributes for app
-  /// extension platforms are ignored.
-  ///
-  /// This attribute may come from an enclosing decl since availability is
-  /// inherited. The second member of the returned pair is the decl that owns
-  /// the attribute.
-  ///
-  /// Note that this notion of unavailability is broader than that which is
-  /// checked by \c isUnavailable().
-  std::optional<std::pair<const AvailableAttr *, const Decl *>>
-  getSemanticUnavailableAttr(bool ignoreAppExtensions = false) 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.
+  /// execution contexts in which the code may run. This result takes the
+  /// availability of parent declarations into account.
   bool isUnreachableAtRuntime() const;
 
   /// Returns true if this declaration should be considered available during

include/swift/AST/TypeCheckRequests.h

@@ -4122,20 +4122,35 @@ class SemanticAvailableRangeAttrRequest
   bool isCached() const { return true; }
 };
 
-class SemanticUnavailableAttrRequest
-    : public SimpleRequest<SemanticUnavailableAttrRequest,
-                           std::optional<AvailableAttrDeclPair>(
-                               const Decl *decl, bool ignoreAppExtensions),
+enum class SemanticDeclAvailability : uint8_t {
+  /// The decl is potentially available in some contexts and/or under certain
+  /// deployment conditions.
+  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),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  std::optional<AvailableAttrDeclPair>
-  evaluate(Evaluator &evaluator, const Decl *decl,
-           bool ignoreAppExtensions) const;
+  SemanticDeclAvailability evaluate(Evaluator &evaluator,
+                                    const Decl *decl) const;
 
 public:
   bool isCached() const { return true; }

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -472,8 +472,8 @@ SWIFT_REQUEST(TypeChecker, RenamedDeclRequest,
 SWIFT_REQUEST(TypeChecker, SemanticAvailableRangeAttrRequest,
               Optional<AvailableAttrDeclPair>(const Decl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, SemanticUnavailableAttrRequest,
-              Optional<AvailableAttrDeclPair>(const Decl *),
+SWIFT_REQUEST(TypeChecker, SemanticDeclAvailabilityRequest,
+              SemanticDeclAvailability(const Decl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ClosureEffectsRequest,
               FunctionType::ExtInfo(ClosureExpr *),

lib/AST/Availability.cpp

@@ -689,60 +689,72 @@ const AvailableAttr *Decl::getUnavailableAttr(bool ignoreAppExtensions) const {
   return nullptr;
 }
 
-std::optional<AvailableAttrDeclPair>
-SemanticUnavailableAttrRequest::evaluate(Evaluator &evaluator, const Decl *decl,
-                                         bool ignoreAppExtensions) const {
-  // Directly marked unavailable.
-  if (auto attr = decl->getUnavailableAttr(ignoreAppExtensions))
-    return std::make_pair(attr, decl);
-
-  if (auto *parent =
-          AvailabilityInference::parentDeclForInferredAvailability(decl))
-    return parent->getSemanticUnavailableAttr(ignoreAppExtensions);
-
-  return std::nullopt;
-}
-
-std::optional<AvailableAttrDeclPair>
-Decl::getSemanticUnavailableAttr(bool ignoreAppExtensions) const {
-  auto &eval = getASTContext().evaluator;
-  return evaluateOrDefault(
-      eval, SemanticUnavailableAttrRequest{this, ignoreAppExtensions},
-      std::nullopt);
-}
-
-bool Decl::isUnreachableAtRuntime() const {
+static bool isDeclCompletelyUnavailable(const Decl *decl) {
   // Don't trust unavailability on declarations from clang modules.
-  if (isa<ClangModuleUnit>(getDeclContext()->getModuleScopeContext()))
+  if (isa<ClangModuleUnit>(decl->getDeclContext()->getModuleScopeContext()))
     return false;
 
-  auto unavailableAttrAndDecl =
-      getSemanticUnavailableAttr(/*ignoreAppExtensions=*/true);
-  if (!unavailableAttrAndDecl)
+  auto *unavailableAttr =
+      decl->getUnavailableAttr(/*ignoreAppExtensions=*/true);
+  if (!unavailableAttr)
     return false;
 
-  // getSemanticUnavailableAttr() can return an @available attribute that makes
-  // its declaration unavailable conditionally due to deployment target. Only
-  // stub or skip a declaration that is unavailable regardless of deployment
-  // target.
-  auto *unavailableAttr = unavailableAttrAndDecl->first;
+  // getUnavailableAttr() can return an @available attribute that is
+  // obsoleted for certain deployment targets or language modes. These decls
+  // can still be reached by code in other modules that is compiled with
+  // a different deployment target or language mode.
   if (!unavailableAttr->isUnconditionallyUnavailable())
     return false;
 
-  // Universally unavailable declarations are always unreachable.
+  // Universally unavailable declarations are always completely unavailable.
   if (unavailableAttr->getPlatform() == PlatformKind::none)
     return true;
 
   // FIXME: 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 (getASTContext().LangOpts.TargetVariant.has_value())
+  if (decl->getASTContext().LangOpts.TargetVariant.has_value())
     return false;
 
   return true;
 }
 
+SemanticDeclAvailability
+SemanticDeclAvailabilityRequest::evaluate(Evaluator &evaluator,
+                                          const Decl *decl) const {
+  auto inherited = SemanticDeclAvailability::PotentiallyAvailable;
+  if (auto *parent =
+          AvailabilityInference::parentDeclForInferredAvailability(decl)) {
+    inherited = evaluateOrDefault(
+        evaluator, SemanticDeclAvailabilityRequest{parent}, inherited);
+  }
+
+  if (inherited == SemanticDeclAvailability::CompletelyUnavailable ||
+      isDeclCompletelyUnavailable(decl))
+    return SemanticDeclAvailability::CompletelyUnavailable;
+
+  if (inherited == SemanticDeclAvailability::ConditionallyUnavailable ||
+      decl->isUnavailable())
+    return SemanticDeclAvailability::ConditionallyUnavailable;
+
+  return SemanticDeclAvailability::PotentiallyAvailable;
+}
+
+bool Decl::isSemanticallyUnavailable() const {
+  auto availability = evaluateOrDefault(
+      getASTContext().evaluator, SemanticDeclAvailabilityRequest{this},
+      SemanticDeclAvailability::PotentiallyAvailable);
+  return availability != SemanticDeclAvailability::PotentiallyAvailable;
+}
+
+bool Decl::isUnreachableAtRuntime() const {
+  auto availability = evaluateOrDefault(
+      getASTContext().evaluator, SemanticDeclAvailabilityRequest{this},
+      SemanticDeclAvailability::PotentiallyAvailable);
+  return availability == SemanticDeclAvailability::CompletelyUnavailable;
+}
+
 static UnavailableDeclOptimization
 getEffectiveUnavailableDeclOptimization(ASTContext &ctx) {
   if (ctx.LangOpts.UnavailableDeclOptimizationMode.has_value())

lib/AST/Decl.cpp

@@ -1300,8 +1300,7 @@ bool Decl::isAlwaysWeakImported() const {
 
   // FIXME: Weak linking on Windows is not yet supported
   // https://github.com/apple/swift/issues/53303
-  if (getSemanticUnavailableAttr() &&
-      !getASTContext().LangOpts.Target.isOSWindows())
+  if (isUnavailable() && !getASTContext().LangOpts.Target.isOSWindows())
     return true;
 
   if (auto *accessor = dyn_cast<AccessorDecl>(this))

lib/SIL/IR/SILProfiler.cpp

@@ -117,7 +117,7 @@ static bool shouldProfile(SILDeclRef Constant) {
 
   if (auto *D = DC->getInnermostDeclarationDeclContext()) {
     // Do not profile AST nodes in unavailable contexts.
-    if (D->getSemanticUnavailableAttr()) {
+    if (D->isSemanticallyUnavailable()) {
       LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: unavailable context\n");
       return false;
     }

lib/Sema/TypeCheckAttr.cpp

@@ -4796,10 +4796,12 @@ void AttributeChecker::checkBackDeployedAttrs(
     if (Attr != ActiveAttr)
       continue;
 
+    auto availability =
+        TypeChecker::availabilityAtLocation(D->getLoc(), D->getDeclContext());
+
     // Unavailable decls cannot be back deployed.
-    if (auto unavailableAttrPair = VD->getSemanticUnavailableAttr()) {
-      auto unavailableAttr = unavailableAttrPair.value().first;
-      if (!inheritsAvailabilityFromPlatform(unavailableAttr->getPlatform(),
+    if (auto unavailablePlatform = availability.getUnavailablePlatformKind()) {
+      if (!inheritsAvailabilityFromPlatform(*unavailablePlatform,
                                             Attr->Platform)) {
         auto platformString = prettyPlatformString(Attr->Platform);
         llvm::VersionTuple ignoredVersion;
@@ -4809,9 +4811,21 @@ void AttributeChecker::checkBackDeployedAttrs(
 
         diagnose(AtLoc, diag::attr_has_no_effect_on_unavailable_decl, Attr, VD,
                  platformString);
-        diagnose(unavailableAttr->AtLoc, diag::availability_marked_unavailable,
-                 VD)
-            .highlight(unavailableAttr->getRange());
+
+        // Find the attribute that makes the declaration unavailable.
+        const Decl *attrDecl = D;
+        do {
+          if (auto *unavailableAttr = attrDecl->getUnavailableAttr()) {
+            diagnose(unavailableAttr->AtLoc,
+                     diag::availability_marked_unavailable, VD)
+                .highlight(unavailableAttr->getRange());
+            break;
+          }
+
+          attrDecl = AvailabilityInference::parentDeclForInferredAvailability(
+              attrDecl);
+        } while (attrDecl);
+
         continue;
       }
     }
@@ -5008,7 +5022,7 @@ TypeChecker::diagnosticIfDeclCannotBeUnavailable(const Decl *D) {
   auto parentIsUnavailable = [](const Decl *D) -> bool {
     if (auto *parent =
             AvailabilityInference::parentDeclForInferredAvailability(D)) {
-      return parent->getSemanticUnavailableAttr() != std::nullopt;
+      return parent->isSemanticallyUnavailable();
     }
     return false;
   };

lib/Sema/TypeCheckAvailability.cpp

@@ -814,11 +814,17 @@ class AvailabilityScopeBuilder : private ASTWalker {
     if (D->getDeclContext()->isLocalContext())
       return false;
 
-    // As a convenience, SPI decls and explicitly unavailable decls are
-    // constrained to the deployment target. There's not much benefit to
-    // checking these declarations at a lower availability version floor since
-    // neither can be used by API clients.
-    if (D->isSPI() || D->getSemanticUnavailableAttr())
+    // As a convenience, explicitly unavailable decls are constrained to the
+    // deployment target. There's not much benefit to checking these decls at a
+    // lower availability version floor since they can't be invoked by clients.
+    if (getCurrentScope()->getAvailabilityContext().isUnavailable() ||
+        D->isUnavailable())
+      return true;
+
+    // To remain compatible with a lot of existing SPIs that are declared
+    // without availability attributes, constrain them to the deployment target
+    // too.
+    if (D->isSPI())
       return true;
 
     return !::isExported(D);

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1924,7 +1924,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->getSemanticUnavailableAttr())
+    if (overrideParent->isSemanticallyUnavailable())
       return {OverrideUnavailabilityStatus::Ignored, nullptr};
   }
 

lib/Sema/TypeCheckProtocol.cpp

@@ -1883,7 +1883,7 @@ RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
       }
 
       if (auto adoptingNominal = DC->getSelfNominalTypeDecl()) {
-        if (adoptingNominal->getSemanticUnavailableAttr())
+        if (adoptingNominal->isSemanticallyUnavailable())
           return true;
       }