RequirementMachine: Fix handling of unavailable Sendable conformances in concretizeNestedTypesFromConcreteParent()

We can't just ignore unavailable conformances because the
generic signature we're computing might itself be attached
to an unavailable declaration.

Until we get a proper fix, only drop unavailable conformances
to Sendable here.

Fixes rdar://problem/94305457.

Author: slavapestov

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -153,10 +153,13 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
     // subclasses of 'C' which are 'Sendable'.
     bool allowMissing = (requirementKind == RequirementKind::SameType);
 
+    bool allowUnavailable =
+        !proto->isSpecificProtocol(KnownProtocolKind::Sendable);
     auto conformance = module->lookupConformance(concreteType,
                                                  const_cast<ProtocolDecl *>(proto),
-                                                 allowMissing);
-    if (conformance.isInvalid() || conformance.hasUnavailableConformance()) {
+                                                 allowMissing,
+                                                 allowUnavailable);
+    if (conformance.isInvalid()) {
       // For superclass rules, it is totally fine to have a signature like:
       //
       // protocol P {}

test/Generics/unavailable_conformances.swift

@@ -0,0 +1,35 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol P { }
+
+struct X { }
+
+@available(*, unavailable)
+extension X: P { }
+
+struct Y<T: P> { }
+
+@available(*, unavailable)
+extension Y {
+  // Okay, because the unavailable conformance is used within an
+  // unavailable context.
+  init() where T == X { }
+}
+
+// A more elaborate setup that hits the conformance check in property map
+// construction rather than concrete contraction.
+
+protocol AssocP {}
+
+@available(*, unavailable)
+struct ConcreteP {}
+
+@available(*, unavailable)
+extension ConcreteP: AssocP {}
+
+protocol Base {
+  associatedtype T : AssocP
+}
+
+@available(*, unavailable)
+extension Base where T == ConcreteP {}

test/decl/protocol/req/recursion.swift

@@ -73,7 +73,7 @@ protocol PI {
 }
 
 struct SI<A: PI> : I where A : I, A.T == SI<A> {
-// expected-error@-1 5{{generic struct 'SI' has self-referential generic requirements}}
+// expected-error@-1 3{{generic struct 'SI' has self-referential generic requirements}}
   func ggg<T : I>(t: T.Type) -> T {
     return T()
   }
@@ -104,5 +104,5 @@ struct SU<A: P> where A.T == SU {
 }
 
 struct SIU<A: PI> : I where A : I, A.T == SIU {
-// expected-error@-1 5{{generic struct 'SIU' has self-referential generic requirements}}
+// expected-error@-1 3{{generic struct 'SIU' has self-referential generic requirements}}
 }

test/decl/protocol/unavailable.swift

@@ -6,7 +6,7 @@ protocol P {
 
 struct Type<Param> {}
 extension Type: P where Param: P, Param.A == Type<Param> {
-  // expected-error@-1 8{{extension of generic struct 'Type' has self-referential generic requirements}}
+  // expected-error@-1 6{{extension of generic struct 'Type' has self-referential generic requirements}}
   // expected-note@-2 6{{through reference here}}
   // expected-error@-3 {{type 'Type<Param>' does not conform to protocol 'P'}}
   typealias A = Param