AST: Track platform unavailability and introduction as separate constraints.

Potential unavailability of a declaration is always diagnosed in a context that
does not have a sufficient platform introduction constraint, even if that
context is also unavailable on that platform. This behavior is overly strict,
since the potential unavailability will never matter, but it's a longstanding
quirk of availability checking. As a result, some source code has been written
to work around this quirk by marking declarations as simultaneously unavailable
and introduced for a given platform:

```
@available(macOS, unavailable, introduced: 15)
func unavailableAndIntroducedInMacOS15() {
  // ... allowed to call functions introduced in macOS 15.
}
```

When availability checking was refactored to be based on a constraint engine in
#79260, the compiler started effectively
treating `@available(macOS, unavailable, introduced: 15)` as just
`@available(macOS, unavailable)` because the introduction constraint was
treated as lower priority and therefore superseded by the unavailability
constraint. This caused a regression for the code that was written to work
around the availability checker's strictness.

The fix is to allow the constraint engine to track multiple kinds of
constraints per-domain which in turn ensures that the platform introduction of
an availability context can be further refined even if that context is also
unavailable.

A better fix would be to stop diagnosing potential unavailability entirely in
unavailable contexts but that change is out of scope for the 6.2 release.

Resolves rdar://147945883.

Author: tshortli

lib/AST/AvailabilityConstraint.cpp

@@ -44,11 +44,7 @@ bool AvailabilityConstraint::isActiveForRuntimeQueries(
 static bool constraintIsStronger(const AvailabilityConstraint &lhs,
                                  const AvailabilityConstraint &rhs) {
   DEBUG_ASSERT(lhs.getDomain() == rhs.getDomain());
-
-  // If the constraints have matching domains but different reasons, the
-  // constraint with the lowest reason is "strongest".
-  if (lhs.getReason() != rhs.getReason())
-    return lhs.getReason() < rhs.getReason();
+  DEBUG_ASSERT(lhs.getReason() == rhs.getReason());
 
   switch (lhs.getReason()) {
   case AvailabilityConstraint::Reason::UnconditionallyUnavailable:
@@ -72,10 +68,12 @@ void addConstraint(llvm::SmallVector<AvailabilityConstraint, 4> &constraints,
 
   auto iter = llvm::find_if(
       constraints, [&constraint](AvailabilityConstraint &existing) {
-        return constraint.getDomain() == existing.getDomain();
+        return constraint.getDomain() == existing.getDomain() &&
+               constraint.getReason() == existing.getReason();
       });
 
-  // There's no existing constraint for the same domain so just add it.
+  // There's no existing constraint with the same domain and reason so just add
+  // the new one.
   if (iter == constraints.end()) {
     constraints.emplace_back(constraint);
     return;
@@ -91,8 +89,8 @@ std::optional<AvailabilityConstraint>
 DeclAvailabilityConstraints::getPrimaryConstraint() const {
   std::optional<AvailabilityConstraint> result;
 
-  auto isStrongerConstraint = [](const AvailabilityConstraint &lhs,
-                                 const AvailabilityConstraint &rhs) {
+  auto isHigherPriorityConstraint = [](const AvailabilityConstraint &lhs,
+                                       const AvailabilityConstraint &rhs) {
     // Constraint reasons are defined in descending order of strength.
     if (lhs.getReason() != rhs.getReason())
       return lhs.getReason() < rhs.getReason();
@@ -106,7 +104,7 @@ DeclAvailabilityConstraints::getPrimaryConstraint() const {
 
   // Pick the strongest constraint.
   for (auto const &constraint : constraints) {
-    if (!result || isStrongerConstraint(constraint, *result))
+    if (!result || isHigherPriorityConstraint(constraint, *result))
       result.emplace(constraint);
   }
 
@@ -137,9 +135,9 @@ isInsideCompatibleUnavailableDeclaration(const Decl *decl,
 /// Returns the `AvailabilityConstraint` that describes how \p attr restricts
 /// use of \p decl in \p context or `std::nullopt` if there is no restriction.
 static std::optional<AvailabilityConstraint>
-getAvailabilityConstraintForAttr(const Decl *decl,
-                                 const SemanticAvailableAttr &attr,
-                                 const AvailabilityContext &context) {
+getUnavailabilityConstraintForAttr(const Decl *decl,
+                                   const SemanticAvailableAttr &attr,
+                                   const AvailabilityContext &context) {
   // Is the decl unconditionally unavailable?
   if (attr.isUnconditionallyUnavailable())
     return AvailabilityConstraint::unconditionallyUnavailable(attr);
@@ -154,6 +152,17 @@ getAvailabilityConstraintForAttr(const Decl *decl,
       return AvailabilityConstraint::obsoleted(attr);
   }
 
+  return std::nullopt;
+}
+
+static std::optional<AvailabilityConstraint>
+getIntroductionConstraintForAttr(const Decl *decl,
+                                 const SemanticAvailableAttr &attr,
+                                 const AvailabilityContext &context) {
+  auto &ctx = decl->getASTContext();
+  auto domain = attr.getDomain();
+  auto deploymentRange = domain.getDeploymentRange(ctx);
+
   // Is the decl not yet introduced in the local context?
   if (auto introducedRange = attr.getIntroducedRange(ctx)) {
     if (domain.supportsContextRefinement()) {
@@ -169,7 +178,6 @@ getAvailabilityConstraintForAttr(const Decl *decl,
       return AvailabilityConstraint::unavailableForDeployment(attr);
   }
 
-  // FIXME: [availability] Model deprecation as an availability constraint.
   return std::nullopt;
 }
 
@@ -210,8 +218,14 @@ static void getAvailabilityConstraintsForDecl(
         !activePlatformDomain->contains(domain))
       continue;
 
-    if (auto constraint = getAvailabilityConstraintForAttr(decl, attr, context))
+    if (auto constraint =
+            getUnavailabilityConstraintForAttr(decl, attr, context))
+      addConstraint(constraints, *constraint, ctx);
+
+    if (auto constraint = getIntroductionConstraintForAttr(decl, attr, context))
       addConstraint(constraints, *constraint, ctx);
+
+    // FIXME: [availability] Model deprecation as an availability constraint.
   }
 
   // After resolving constraints, remove any constraints that indicate the

test/Sema/availability_scopes.swift

@@ -416,12 +416,27 @@ extension SomeEnum {
   func neverAvailable() {}
 }
 
-// CHECK-NEXT: {{^}}  (decl version=50 unavailable=macOS decl=unavailableOnMacOSAndIntroduced()
+// CHECK-NEXT: {{^}}  (decl version=52 unavailable=macOS decl=unavailableOnMacOSAndIntroduced()
 
-@available(macOS, unavailable, introduced: 52)
+@available(macOS, unavailable)
+@available(macOS, introduced: 52)
 func unavailableOnMacOSAndIntroduced() {
 }
 
+// CHECK-NEXT: {{^}}  (decl version=53 unavailable=macOS decl=introducedOnMacOSAndUnavailable()
+
+@available(macOS, introduced: 53)
+@available(macOS, unavailable)
+func introducedOnMacOSAndUnavailable() {
+}
+
+
+// CHECK-NEXT: {{^}}  (decl version=54 unavailable=macOS decl=unavailableOnMacOSAndIntroducedSameAttr()
+
+@available(macOS, unavailable, introduced: 54)
+func unavailableOnMacOSAndIntroducedSameAttr() {
+}
+
 // CHECK-NEXT: {{^}}  (decl version=50 unavailable=* decl=NeverAvailable
 // CHECK-NEXT: {{^}}    (decl version=50 unavailable=* decl=unavailableOnMacOS()
 

test/attr/attr_availability_transitive_osx.swift

@@ -534,7 +534,7 @@ func available_func_call_extension_methods(_ e: ExtendMe) { // expected-note {{a
 }
 
 @available(OSX, obsoleted: 10.9)
-struct OSXObsoleted {} // expected-note 2 {{'OSXObsoleted' was obsoleted in macOS 10.9}}
+struct OSXObsoleted {} // expected-note 4 {{'OSXObsoleted' was obsoleted in macOS 10.9}}
 
 @available(OSX, unavailable)
 @available(OSX, introduced: 99)
@@ -565,18 +565,51 @@ func osx_unavailable_func(
   _ = OSXFutureAvailable() // expected-error {{'OSXFutureAvailable' is only available in macOS 99 or newer}}
   // expected-note@-1 {{add 'if #available' version check}}
   _ = OSXObsoleted() // expected-error {{'OSXObsoleted' is unavailable in macOS}}
-  _ = OSXUnavailableAndIntroducedInFuture()
+  _ = OSXUnavailableAndIntroducedInFuture() // expected-error {{'OSXUnavailableAndIntroducedInFuture' is only available in macOS 99 or newer}}
+  // expected-note@-1 {{add 'if #available' version check}}
   _ = OSXUnavailableAndIntroducedInFutureSameAttribute()
-  _ = OSXIntroducedInFutureAndUnavailable()
+  _ = OSXIntroducedInFutureAndUnavailable()  // expected-error {{'OSXIntroducedInFutureAndUnavailable' is only available in macOS 99 or newer}}
+  // expected-note@-1 {{add 'if #available' version check}}
 
   func takesType<T>(_ t: T.Type) {}
   takesType(OSXFutureAvailable.self) // expected-error {{'OSXFutureAvailable' is only available in macOS 99 or newer}}
   // expected-note@-1 {{add 'if #available' version check}}
   takesType(OSXObsoleted.self) // expected-error {{'OSXObsoleted' is unavailable in macOS}}
+  takesType(OSXUnavailableAndIntroducedInFuture.self) // expected-error {{'OSXUnavailableAndIntroducedInFuture' is only available in macOS 99 or newer}}
+  // expected-note@-1 {{add 'if #available' version check}}
+  takesType(OSXUnavailableAndIntroducedInFutureSameAttribute.self)
+  takesType(OSXIntroducedInFutureAndUnavailable.self) // expected-error {{'OSXIntroducedInFutureAndUnavailable' is only available in macOS 99 or newer}}
+  // expected-note@-1 {{add 'if #available' version check}}
+
+  return (s1, s2, s3, s4, s5)
+}
+
+@available(OSX, introduced: 99, unavailable)
+func osx_unavailable_and_future_func(
+  _ s1: OSXFutureAvailable,
+  _ s2: OSXObsoleted,
+  _ s3: OSXUnavailableAndIntroducedInFuture,
+  _ s4: OSXUnavailableAndIntroducedInFutureSameAttribute,
+  _ s5: OSXIntroducedInFutureAndUnavailable,
+) -> (
+  OSXFutureAvailable,
+  OSXObsoleted,
+  OSXUnavailableAndIntroducedInFuture,
+  OSXUnavailableAndIntroducedInFutureSameAttribute,
+  OSXIntroducedInFutureAndUnavailable
+) {
+  _ = OSXFutureAvailable()
+  _ = OSXObsoleted() // expected-error {{'OSXObsoleted' is unavailable in macOS}}
+  _ = OSXUnavailableAndIntroducedInFuture()
+  _ = OSXUnavailableAndIntroducedInFutureSameAttribute()
+  _ = OSXIntroducedInFutureAndUnavailable()
+
+  func takesType<T>(_ t: T.Type) {}
+  takesType(OSXFutureAvailable.self)
+  takesType(OSXObsoleted.self) // expected-error {{'OSXObsoleted' is unavailable in macOS}}
   takesType(OSXUnavailableAndIntroducedInFuture.self)
   takesType(OSXUnavailableAndIntroducedInFutureSameAttribute.self)
   takesType(OSXIntroducedInFutureAndUnavailable.self)
 
   return (s1, s2, s3, s4, s5)
 }
-

test/attr/attr_availability_transitive_osx_appext.swift

@@ -385,7 +385,8 @@ func osx_func_call_extension_methods(_ e: ExtendMe) {
   e.osx_extension_osx_app_extension_method()
 
   e.never_available_extension_osx_future_method() // expected-error {{'never_available_extension_osx_future_method()' is unavailable}}
-  e.osx_extension_osx_future_method()
+  e.osx_extension_osx_future_method() // expected-error {{'osx_extension_osx_future_method()' is only available in macOS 99 or newer}}
+  // expected-note@-1 {{add 'if #available' version check}}
   e.osx_app_extension_extension_osx_future_method() // expected-error {{'osx_app_extension_extension_osx_future_method()' is only available in macOS 99 or newer}}
   // expected-note@-1 {{add 'if #available' version check}}
   e.osx_app_extension_extension_never_available_method() // expected-error {{'osx_app_extension_extension_never_available_method()' is unavailable}}