Sema: Correctly treat overloads in unavailable extensions as unavailable.

Instead of checking for unavailability attributes directly in the solver, which
does not correctly handle members of unavailable extensions, query
`checkDeclarationAvailability()` instead. By using the same underlying logic as
the availability checker the constraint solver can be confident in the accuracy
of this result.

Resolves rdar://87403752.

Author: tshortli

lib/Sema/ConstraintSystem.cpp

@@ -4676,20 +4676,14 @@ void ConstraintSystem::diagnoseFailureFor(SyntacticElementTarget target) {
 
 bool ConstraintSystem::isDeclUnavailable(const Decl *D,
                                          ConstraintLocator *locator) const {
-  // First check whether this declaration is universally unavailable.
-  if (D->getAttrs().isUnavailable(getASTContext()))
-    return true;
-
-  return TypeChecker::isDeclarationUnavailable(D, DC, [&] {
-    SourceLoc loc;
-
-    if (locator) {
-      if (auto anchor = locator->getAnchor())
-        loc = getLoc(anchor);
-    }
+  SourceLoc loc;
+  if (locator) {
+    if (auto anchor = locator->getAnchor())
+      loc = getLoc(anchor);
+  }
 
-    return TypeChecker::overApproximateAvailabilityAtLocation(loc, DC);
-  });
+  auto availabilityContext = TypeChecker::availabilityAtLocation(loc, DC);
+  return checkDeclarationAvailability(D, DC, availabilityContext).has_value();
 }
 
 bool ConstraintSystem::isConformanceUnavailable(ProtocolConformanceRef conformance,

lib/Sema/TypeCheckAvailability.cpp

@@ -2205,6 +2205,8 @@ diagnosePotentialUnavailability(const ValueDecl *D, SourceRange ReferenceRange,
                                 const AvailabilityRange &Availability,
                                 bool WarnBeforeDeploymentTarget = false) {
   ASTContext &Context = ReferenceDC->getASTContext();
+  if (Context.LangOpts.DisableAvailabilityChecking)
+    return false;
 
   bool IsError;
   {
@@ -3100,8 +3102,6 @@ swift::checkDeclarationAvailability(const Decl *decl,
                                     const DeclContext *declContext,
                                     AvailabilityContext availabilityContext) {
   auto &ctx = declContext->getASTContext();
-  if (ctx.LangOpts.DisableAvailabilityChecking)
-    return std::nullopt;
 
   // Generic parameters are always available.
   if (isa<GenericTypeParamDecl>(decl))
@@ -4150,6 +4150,7 @@ bool swift::diagnoseDeclAvailability(const ValueDecl *D, SourceRange R,
 
   auto *DC = Where.getDeclContext();
   auto &ctx = DC->getASTContext();
+
   auto unmetRequirement =
       checkDeclarationAvailability(D, DC, Where.getAvailability());
   auto requiredRange =

test/Constraints/availability.swift

@@ -64,3 +64,25 @@ extension Box where T == Int {
   // memberwise initializer.
   _ = Box(value: 42)
 }
+
+// rdar://87403752 - ambiguity with member declared in unavailable extension
+struct HasUnavailableExtesion {
+}
+
+@available(*, unavailable)
+extension HasUnavailableExtesion {
+  static var foo: Self = HasUnavailableExtesion()
+}
+
+func test_contextual_member_with_unavailable_extension() {
+  struct A {
+    static var foo: A = A()
+  }
+
+  struct Test {
+    init(_: A) {}
+    init(_: HasUnavailableExtesion) {}
+  }
+
+  _ = Test(.foo) // Ok `A.foo` since `foo` from `HasUnavailableExtesion` is unavailable
+}

test/embedded/availability.swift

@@ -21,8 +21,8 @@ public func universally_unavailable() { }
 @_unavailableInEmbedded
 public func unused() { } // no error
 
-public struct S1 {}
-public struct S2 {}
+public struct S1 {} // expected-note {{found this candidate}}
+public struct S2 {} // expected-note {{found this candidate}}
 
 @_unavailableInEmbedded
 public func has_unavailable_in_embedded_overload(_ s1: S1) { }
@@ -47,11 +47,11 @@ public func available(
 @_unavailableInEmbedded
 public func also_unavailable_in_embedded(
   _ uie: UnavailableInEmbedded, // OK
-  _ uu: UniverallyUnavailable // FIXME: should be an error
+  _ uu: UniverallyUnavailable // OK
 ) {
   unavailable_in_embedded() // OK
   universally_unavailable() // expected-error {{'universally_unavailable()' is unavailable: always unavailable}}
-  has_unavailable_in_embedded_overload(.init()) // FIXME: should be ambiguous
+  has_unavailable_in_embedded_overload(.init()) // expected-error {{ambiguous use of 'init()'}}
   has_universally_unavailable_overload(.init()) // not ambiguous, selects available overload
 }