Allow unavailable conformances to non-Sendaable protocols during contraction

Refusing to acknowledge unavailable conformances at this point in the
requirement machine doesn't allow us to make use of unavailable
conformances from unavailable contexts, something which code currently
depends on. Limit the new filtering behavior to `Sendable` conformances
where we need them, as a narrow fix for this regression. We'll revisit
the approach here later.

Fixes rdar://94154905.

Author: DougGregor

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -271,14 +271,16 @@ Optional<Type> ConcreteContraction::substTypeParameterRec(
       auto *proto = assocType->getProtocol();
       auto *module = proto->getParentModule();
 
+      bool allowUnavailable =
+          !proto->isSpecificProtocol(KnownProtocolKind::Sendable);
       // The 'Sendable' protocol does not declare any associated types, so the
       // 'allowMissing' value here is actually irrelevant.
       auto conformance = ((*substBaseType)->isTypeParameter()
                           ? ProtocolConformanceRef(proto)
                           : module->lookupConformance(
                               *substBaseType, proto,
                               /*allowMissing=*/false,
-                              /*allowUnavailable=*/false));
+                              allowUnavailable));
 
       // The base type doesn't conform, in which case the requirement remains
       // unsubstituted.
@@ -391,9 +393,11 @@ ConcreteContraction::substRequirement(const Requirement &req) const {
     if (ConcreteTypes.count(stripBoundDependentMemberTypes(firstType)) > 0)
       allowMissing = true;
 
+    bool allowUnavailable =
+        !proto->isSpecificProtocol(KnownProtocolKind::Sendable);
     if (!substFirstType->isTypeParameter() &&
         !module->lookupConformance(substFirstType, proto,
-                                   allowMissing, /*allowUnavailable=*/false)) {
+                                   allowMissing, allowUnavailable)) {
       // Handle the case of <T where T : P, T : C> where C is a class and
       // C does not conform to P by leaving the conformance requirement
       // unsubstituted.

test/Generics/superclass_constraint.swift

@@ -230,5 +230,7 @@ extension Animal: Pony { }
 
 public struct AnimalWrapper<Friend: Animal> { }
 
-// CHECK: Generic signature: <Friend where Friend : Animal, Friend : Pony>
+// FIXME: Generic signature: <Friend where Friend : Animal, Friend : Pony>
+// Generic signature: <Friend where Friend : Animal>
 extension AnimalWrapper: Pony where Friend: Pony { }
+// expected-warning@-1{{redundant conformance constraint 'Animal' : 'Pony'}}

test/decl/protocol/unavailable.swift

@@ -0,0 +1,17 @@
+// 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 { }
+}