Merge pull request #83700 from tshortli/check-obsoletion-with-contextual-availability

Author: tshortli

lib/AST/AvailabilityConstraint.cpp

@@ -205,26 +205,23 @@ getAvailabilityConstraintForAttr(const Decl *decl,
   auto &ctx = decl->getASTContext();
   auto domain = attr.getDomain();
   auto deploymentRange = domain.getDeploymentRange(ctx);
+  bool domainSupportsRefinement = domain.supportsContextRefinement();
+  std::optional<AvailabilityRange> availableRange =
+      domainSupportsRefinement ? context.getAvailabilityRange(domain, ctx)
+                               : deploymentRange;
 
-  // Is the decl obsoleted in the deployment context?
+  // Is the decl obsoleted in this context?
   if (auto obsoletedRange = attr.getObsoletedRange(ctx)) {
-    if (deploymentRange && deploymentRange->isContainedIn(*obsoletedRange))
+    if (availableRange && availableRange->isContainedIn(*obsoletedRange))
       return AvailabilityConstraint::unavailableObsolete(attr);
   }
 
-  // Is the decl not yet introduced in the local context?
+  // Is the decl not yet introduced in this context?
   if (auto introducedRange = attr.getIntroducedRange(ctx)) {
-    if (domain.supportsContextRefinement()) {
-      auto availableRange = context.getAvailabilityRange(domain, ctx);
-      if (!availableRange || !availableRange->isContainedIn(*introducedRange))
-        return AvailabilityConstraint::unintroduced(attr);
-
-      return std::nullopt;
-    }
-
-    // Is the decl not yet introduced in the deployment context?
-    if (deploymentRange && !deploymentRange->isContainedIn(*introducedRange))
-      return AvailabilityConstraint::unavailableUnintroduced(attr);
+    if (!availableRange || !availableRange->isContainedIn(*introducedRange))
+      return domainSupportsRefinement
+                 ? AvailabilityConstraint::unintroduced(attr)
+                 : AvailabilityConstraint::unavailableUnintroduced(attr);
   }
 
   return std::nullopt;

lib/AST/AvailabilityContext.cpp

@@ -355,10 +355,13 @@ void AvailabilityContext::constrainWithDecl(const Decl *decl) {
 void AvailabilityContext::constrainWithDeclAndPlatformRange(
     const Decl *decl, const AvailabilityRange &otherPlatformRange) {
   auto &ctx = decl->getASTContext();
+
+  // Constrain the platform range first since this may have an effect on
+  // whether the decl is considered obsolete.
+  constrainWithPlatformRange(otherPlatformRange, ctx);
+
   bool isConstrained = false;
   auto platformRange = storage->platformRange;
-  isConstrained |= constrainRange(platformRange, otherPlatformRange);
-
   bool isDeprecated = storage->isDeprecated;
   isConstrained |= constrainBool(isDeprecated, decl->isDeprecated());
 

lib/AST/AvailabilityScopeBuilder.cpp

@@ -18,6 +18,7 @@
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTWalker.h"
+#include "swift/AST/AvailabilityConstraint.h"
 #include "swift/AST/AvailabilityInference.h"
 #include "swift/AST/AvailabilitySpec.h"
 #include "swift/AST/Decl.h"
@@ -461,10 +462,17 @@ class AvailabilityScopeBuilder : private ASTWalker {
     // 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() ||
-        decl->isUnavailable())
+    auto context = getCurrentScope()->getAvailabilityContext();
+    if (context.isUnavailable())
       return true;
 
+    // Check whether the decl is unavailable relative to the current context.
+    if (auto constraint = getAvailabilityConstraintsForDecl(decl, context)
+                              .getPrimaryConstraint()) {
+      if (constraint->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.
@@ -584,8 +592,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
   }
 
   void buildContextsForBodyOfDecl(Decl *decl) {
-    // Are we already constrained by the deployment target and the declaration
-    // doesn't explicitly allow unsafe constructs in its definition, adding
+    // If we are already constrained by the deployment target then adding
     // new contexts won't change availability.
     if (isCurrentScopeContainedByDeploymentTarget())
       return;
@@ -599,8 +606,10 @@ class AvailabilityScopeBuilder : private ASTWalker {
       // Apply deployment-target availability if appropriate for this body.
       if (!isCurrentScopeContainedByDeploymentTarget() &&
           bodyIsDeploymentTarget(decl)) {
-        availability.constrainWithPlatformRange(
-            AvailabilityRange::forDeploymentTarget(Context), Context);
+        // Also constrain availability with the decl itself to handle the case
+        // where the decl becomes obsolete at the deployment target.
+        availability.constrainWithDeclAndPlatformRange(
+            decl, AvailabilityRange::forDeploymentTarget(Context));
       }
 
       nodesAndScopes.push_back(