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/Availability.cpp

@@ -926,6 +926,9 @@ SemanticAvailableAttr::getIntroducedDomainAndRange(
   auto *attr = getParsedAttr();
   auto domain = getDomain();
 
+  if (domain.isUniversal())
+    return std::nullopt;
+
   if (!attr->getRawIntroduced().has_value()) {
     // For versioned domains, an "introduced:" version is always required to
     // indicate introduction.

lib/AST/AvailabilityConstraint.cpp

@@ -44,19 +44,24 @@ void AvailabilityConstraint::print(llvm::raw_ostream &os) const {
   getAttr().getDomain().print(os);
   os << ", ";
 
+  std::optional<llvm::VersionTuple> version;
   switch (getReason()) {
   case Reason::UnavailableUnconditionally:
     os << "unavailable";
     break;
   case Reason::UnavailableObsolete:
-    os << "obsoleted: " << getAttr().getObsoleted().value();
+    os << "obsoleted";
+    version = getAttr().getObsoleted();
     break;
   case Reason::UnavailableUnintroduced:
   case Reason::Unintroduced:
-    os << "introduced: " << getAttr().getIntroduced().value();
+    os << "introduced";
+    version = getAttr().getIntroduced();
     break;
   }
 
+  if (version)
+    os << ": " << *version;
   os << ")";
 }
 
@@ -219,26 +224,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;