Allow unavailable conformances to non-Sendaable protocols during contraction

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 { }
+}