Respect @available(*, unavailable) in Sendable checking.

When a type has provided an unavailable `Sendable` conformance, don't
check its instance storage for `Sendable`. Additionally, teach
`-require-explicit-sendable` to avoid trying to add a `Sendable`
conformance when some of the instance storage relies on unavailable
`Sendable` conformances.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -730,6 +730,29 @@ void swift::diagnoseMissingSendableConformance(
 }
 
 namespace {
+  /// Determine whether there is an unavailable conformance here.
+  static bool hasUnavailableConformance(ProtocolConformanceRef conformance) {
+    // Abstract conformances are never unavailable.
+    if (!conformance.isConcrete())
+      return false;
+
+    // Check whether this conformance is on an unavailable extension.
+    auto concrete = conformance.getConcrete();
+    auto ext = dyn_cast<ExtensionDecl>(concrete->getDeclContext());
+    if (ext && AvailableAttr::isUnavailable(ext))
+      return true;
+
+    // Check the conformances in the substitution map.
+    auto module = concrete->getDeclContext()->getParentModule();
+    auto subMap = concrete->getSubstitutions(module);
+    for (auto subConformance : subMap.getConformances()) {
+      if (hasUnavailableConformance(subConformance))
+        return true;
+    }
+
+    return false;
+  }
+
   template<typename Visitor>
   bool visitInstanceStorage(
       NominalTypeDecl *nominal, DeclContext *dc, Visitor &visitor);
@@ -777,7 +800,9 @@ namespace {
         if (conformance.isInvalid())
           return true;
 
-        // FIXME: Look for unavailable conformances, too!
+        // If there is an unavailable conformance here, fail.
+        if (hasUnavailableConformance(conformance))
+          return true;
 
         // Look for missing Sendable conformances.
         return conformance.forEachMissingConformance(module,
@@ -3726,6 +3751,12 @@ bool swift::checkSendableConformance(
   if (!nominal)
     return false;
 
+  // If this is an always-unavailable conformance, there's nothing to check.
+  if (auto ext = dyn_cast<ExtensionDecl>(conformanceDC)) {
+    if (AvailableAttr::isUnavailable(ext))
+      return false;
+  }
+
   auto classDecl = dyn_cast<ClassDecl>(nominal);
   if (classDecl) {
     // Actors implicitly conform to Sendable and protect their state.

test/Concurrency/concurrent_value_inference.swift

@@ -96,6 +96,14 @@ class C3 { }
 
 class C4: C3 { }
 
+// Make Sendable unavailable, but be sure not to diagnose it.
+struct S2 {
+  var c1: C1
+}
+
+@available(*, unavailable)
+extension S2: Sendable { }
+
 func testCV(
   c1: C1, c2: C2, c3: C3, c4: C4, s1: S1, e1: E1, e2: E2,
   gs1: GS1<Int>, gs2: GS2<Int>,

test/Concurrency/require-explicit-sendable.swift

@@ -87,3 +87,9 @@ public struct S9<T: P2 & Hashable> {
   // expected-note@-3{{make generic struct 'S9' explicitly non-Sendable to suppress this warning}}
   var dict: [T : T.A] = [:]
 }
+
+public struct S10 { // expected-warning{{public struct 'S10' does not specify whether it is 'Sendable' or not}}
+  // expected-note@-1{{add '@unchecked Sendable' conformance to struct 'S10' if this type manually implements concurrency safety}}
+  // expected-note@-2{{make struct 'S10' explicitly non-Sendable to suppress this warning}}
+  var s7: S7
+}