AST: Allow overloads to be disambiguated by obsoletion version.

Previously, whether a declaration is unavailable because it is obsolete was
determined based solely on the deployment target and not based on contextual
availability. Taking contextual availability into account makes availability
checking more internally consistent and allows library authors to evolve APIs
by obsoleting the previous declaration while introducing a new declaration in the
same version:

```
@available(macOS, obsoleted: 15)
func foo(_ x: Int) { }

@available(macOS, introduced: 15)
func foo(_ x: Int, y: Int = 0) { }

foo(42) // unambiguous, regardless of contextual version of macOS
```

This change primarily accepts more code that wasn't accepted previously, but it
could also be source breaking for some code that was previously allowed to use
obsoleted declarations in contexts that will always run on OS versions where
the declaration is obsolete. That code was clearly taking advantage of an
availabilty loophole, though, and in practice I don't expect it to be common.

Resolves rdar://144647964.

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(